func start(c *exec.Cmd) (io.ReadCloser, io.WriteCloser, error) {
c.SysProcAttr = &syscall.SysProcAttr{}
//c.SysProcAttr.CreationFlags = 16 // CREATE_NEW_CONSOLE
stdin, err := c.StdinPipe()
if err != nil {
return nil, nil, err
}
stdout, err := c.StdoutPipe()
if err != nil {
return nil, nil, err
}
stderr, err := c.StderrPipe()
if err != nil {
return nil, nil, err
}
t := &term{}
t.cmd = c
t.stderr = stderr
t.stdout = stdout
t.stdin = stdin
err = t.start()
if err != nil {
return nil, nil, err
}
return t, t, nil
}
func rsyncWebsocket(cmd *exec.Cmd, conn *websocket.Conn) error {
stdin, err := cmd.StdinPipe()
if err != nil {
return err
}
stdout, err := cmd.StdoutPipe()
if err != nil {
return err
}
stderr, err := cmd.StderrPipe()
if err != nil {
return err
}
if err := cmd.Start(); err != nil {
return err
}
shared.WebsocketMirror(conn, stdin, stdout)
data, err2 := ioutil.ReadAll(stderr)
if err2 != nil {
shared.Debugf("error reading rsync stderr: %s", err2)
return err2
}
shared.Debugf("Stderr from rsync: %s", data)
err = cmd.Wait()
if err != nil {
shared.Debugf("rsync recv error %s: %s", err, string(data))
}
return err
}
func attachCmd(cmd *exec.Cmd, stdout, stderr io.Writer, stdin io.Reader) (*sync.WaitGroup, error) {
var wg sync.WaitGroup
wg.Add(2)
stdinIn, err := cmd.StdinPipe()
if err != nil {
return nil, err
}
stdoutOut, err := cmd.StdoutPipe()
if err != nil {
return nil, err
}
stderrOut, err := cmd.StderrPipe()
if err != nil {
return nil, err
}
go func() {
io.Copy(stdinIn, stdin)
stdinIn.Close()
}()
go func() {
io.Copy(stdout, stdoutOut)
wg.Done()
}()
go func() {
io.Copy(stderr, stderrOut)
wg.Done()
}()
return &wg, nil
}
func gatherCmdOutput(taskName string, cmd *exec.Cmd, eventsChan chan *types.Event) error {
stdoutReader, err := cmd.StdoutPipe()
if err != nil {
return err
}
stderrReader, err := cmd.StderrPipe()
if err != nil {
return err
}
stdoutScanner := bufio.NewScanner(stdoutReader)
stderrScanner := bufio.NewScanner(stderrReader)
go func() {
for stdoutScanner.Scan() {
eventsChan <- types.NewOutputEvent(taskName, stdoutScanner.Bytes())
}
}()
go func() {
for stderrScanner.Scan() {
eventsChan <- types.NewOutputEvent(taskName, stderrScanner.Bytes())
}
}()
return nil
}
func attachCmd(cmd *exec.Cmd, ch ssh.Channel) (*sync.WaitGroup, error) {
var wg sync.WaitGroup
wg.Add(3)
stdout, err := cmd.StdoutPipe()
if err != nil {
return nil, err
}
stderr, err := cmd.StderrPipe()
if err != nil {
return nil, err
}
stdin, err := cmd.StdinPipe()
if err != nil {
return nil, err
}
go func() {
defer wg.Done()
io.Copy(stdin, ch)
}()
go func() {
defer wg.Done()
io.Copy(ch.Stderr(), stderr)
}()
go func() {
defer wg.Done()
io.Copy(ch, stdout)
}()
return &wg, nil
}
func (c *EtcdAdapter) ExecWithLog(cmd *exec.Cmd, i int) {
stdoutPipe, err := cmd.StdoutPipe()
check(err)
stderrPipe, err := cmd.StderrPipe()
check(err)
outFile, err := os.Create(fmt.Sprintf("/tmp/etcd_%d.out", i))
check(err)
errFile, err := os.Create(fmt.Sprintf("/tmp/etcd_%d.err", i))
check(err)
outWriter := bufio.NewWriter(outFile)
errWriter := bufio.NewWriter(errFile)
defer outWriter.Flush()
defer errWriter.Flush()
// Start the command
err = cmd.Start()
check(err)
go io.Copy(outWriter, stdoutPipe)
go io.Copy(errWriter, stderrPipe)
c.launchProcess <- cmd.Process
cmd.Wait()
}
// execCmd executes the given command, and returns the stdout and stderr output.
// `logLineTitle` is the prefix for logging to the container log.
func execCmd(cmd *exec.Cmd, logLineTitle string) (string, string, error) {
l := log.cmdLogger
l.infoln(fmt.Sprintf("%s: Starting command: %v", logLineTitle, cmd.Args))
stdoutPipe, err := cmd.StdoutPipe()
if err != nil {
return "", "", err
}
stderrPipe, err := cmd.StderrPipe()
if err != nil {
return "", "", err
}
// Save the command output while logging it.
logFormatter := logLineTitle + " (%s): %%s"
stdoutChan := logAndUpdate(*bufio.NewScanner(stdoutPipe), l,
fmt.Sprintf(logFormatter, "stdout"))
stderrChan := logAndUpdate(*bufio.NewScanner(stderrPipe), l,
fmt.Sprintf(logFormatter, "stderr"))
if err := cmd.Start(); err != nil {
return "", "", err
}
stdout := <-stdoutChan
stderr := <-stderrChan
err = cmd.Wait()
l.infoln(fmt.Sprintf("%s: Completed command: %v", logLineTitle, cmd.Args))
return stdout, stderr, err
}
// Initialize a new ExecutablePlugin from path to executable and daemon mode (true or false)
func NewExecutablePlugin(a Arg, path string) (*ExecutablePlugin, error) {
jsonArgs, err := json.Marshal(a)
if err != nil {
return nil, err
}
// Init the cmd
cmd := new(exec.Cmd)
cmd.Path = path
cmd.Args = []string{path, string(jsonArgs)}
// Link the stdout for response reading
stdout, err := cmd.StdoutPipe()
if err != nil {
return nil, err
}
stderr, err := cmd.StderrPipe()
if err != nil {
return nil, err
}
// Init the ExecutablePlugin and return
ePlugin := new(ExecutablePlugin)
ePlugin.cmd = cmd
ePlugin.stdout = stdout
ePlugin.args = a
ePlugin.stderr = stderr
return ePlugin, nil
}
func execTimeout(timeout time.Duration, cmd *exec.Cmd) ([]byte, error) {
stdout, err := cmd.StdoutPipe()
if err != nil {
return nil, err
}
stderr, err := cmd.StderrPipe()
if err != nil {
return nil, err
}
err = cmd.Start()
if err != nil {
return nil, err
}
b := bytes.NewBuffer([]byte{})
go io.Copy(b, stdout)
go io.Copy(b, stderr)
_, timedOut, err := withtimeout.Do(timeout, func() (interface{}, error) {
return nil, cmd.Wait()
})
if err != nil {
if timedOut {
go cmd.Process.Kill()
}
return nil, err
}
return b.Bytes(), nil
}
// ExecuteWithOutput executes a command. If logrus's verbosity level is set to
// debug, it will continuously output the command's output while it waits.
func ExecuteWithOutput(cmd *exec.Cmd) (outStr string, err error) {
// connect to stdout and stderr for filtering purposes
errPipe, err := cmd.StderrPipe()
if err != nil {
log.WithFields(log.Fields{
"cmd": cmd.Args,
}).Fatal("Couldn't connect to command's stderr")
}
outPipe, err := cmd.StdoutPipe()
if err != nil {
log.WithFields(log.Fields{
"cmd": cmd.Args,
}).Fatal("Couldn't connect to command's stdout")
}
_ = bufio.NewReader(errPipe)
outReader := bufio.NewReader(outPipe)
// start the command and filter the output
if err = cmd.Start(); err != nil {
return "", err
}
outScanner := bufio.NewScanner(outReader)
for outScanner.Scan() {
outStr += outScanner.Text() + "\n"
if log.GetLevel() == log.DebugLevel {
fmt.Println(outScanner.Text())
}
}
err = cmd.Wait()
return outStr, err
}
func pipeCommandToFile(cmd *exec.Cmd, path string) error {
file, err := os.Create(path)
if err != nil {
return err
}
defer file.Close()
stdout, err := cmd.StdoutPipe()
if err != nil {
return err
}
stderr, err := cmd.StderrPipe()
if err != nil {
return err
}
err = cmd.Start()
if err != nil {
return err
}
go io.Copy(os.Stdout, stderr)
io.Copy(file, stdout)
return cmd.Wait()
}
func execWithOutput(cmd *exec.Cmd, outWriter io.Writer, errWriter io.Writer) (err error) {
plog.Info(map[string]interface{}{
"event": "exec_command",
"cmd": fmt.Sprintf("[%s] %s %v", cmd.Dir, cmd.Path, cmd.Args),
})
stdout, err := cmd.StdoutPipe()
if err != nil {
return
}
stderr, err := cmd.StderrPipe()
if err != nil {
return
}
err = cmd.Start()
if err != nil {
return
}
go io.Copy(outWriter, stdout)
defer stdout.Close()
go io.Copy(errWriter, stderr)
defer stderr.Close()
err = cmd.Wait()
return
}
func (c *ClientServer) preprocessFile(cmd *exec.Cmd, f io.Reader) ([]byte, error) {
if stdout, err := cmd.StdoutPipe(); err == nil {
if stdin, err := cmd.StdinPipe(); err == nil {
if stderr, err := cmd.StderrPipe(); err == nil {
if err := cmd.Start(); err == nil {
if b, err := ioutil.ReadAll(f); err == nil {
stdin.Write(b)
stdin.Close()
out, _ := ioutil.ReadAll(stdout)
stde, _ := ioutil.ReadAll(stderr)
if e := cmd.Wait(); e == nil {
return out, nil
} else {
return stde, fmt.Errorf("Preprocessor failed.")
}
} else {
return nil, err
}
} else {
return nil, err
}
} else {
return nil, err
}
} else {
return nil, err
}
} else {
return nil, err
}
}
func runCmdTeeStdio(cmd *exec.Cmd, stdOutPath, stdErrPath string) error {
stdout, err := cmd.StdoutPipe()
if err != nil {
return fmt.Errorf("Error running caffe: StdoutPipe(). Err: %v", err)
}
stderr, err := cmd.StderrPipe()
if err != nil {
return fmt.Errorf("Error running caffe: StderrPipe(). Err: %v", err)
}
if err := cmd.Start(); err != nil {
return fmt.Errorf("Error running caffe: cmd.Start(). Err: %v", err)
}
// read from stdout, stderr and write to temp files
if err := saveCmdOutputToFiles(stdout, stderr, stdOutPath, stdErrPath); err != nil {
return fmt.Errorf("Error running command: saveCmdOutput. Err: %v", err)
}
// wait for the command to complete
runCommandErr := cmd.Wait()
return runCommandErr
}
// RunCommandWithStdoutStderr execs a command and returns its output.
func RunCommandWithStdoutStderr(cmd *exec.Cmd) (bytes.Buffer, bytes.Buffer, error) {
var stdout, stderr bytes.Buffer
stderrPipe, err := cmd.StderrPipe()
stdoutPipe, err := cmd.StdoutPipe()
cmd.Env = os.Environ()
if err != nil {
fmt.Println("error at io pipes")
}
err = cmd.Start()
if err != nil {
fmt.Println("error at command start")
}
go func() {
streamOutput(stdoutPipe, &stdout, os.Stdout)
}()
go func() {
streamOutput(stderrPipe, &stderr, os.Stderr)
}()
err = cmd.Wait()
if err != nil {
fmt.Println("error at command wait")
}
return stdout, stderr, err
}
func ExecGenCmd(args []string) (string, error) {
var cmd *exec.Cmd
argsNew := make([]string, len(args)+1)
argsNew[0] = "generate"
for i, a := range args {
argsNew[i+1] = a
}
cmd = exec.Command("./ocitools", argsNew...)
cmd.Dir = "./plugins"
// cmd.stdin = os.Stdin
stderr, err := cmd.StderrPipe()
if err != nil {
log.Fatal("stderr err %v", err)
}
stdout, err := cmd.StdoutPipe()
if err != nil {
log.Fatalf("stdout err %v", err)
}
var retStr string
err = cmd.Start()
if err != nil {
retb, _ := ioutil.ReadAll(stderr)
retStr = string(retb)
// stdoutReader.ReadRune()
} else {
retb, _ := ioutil.ReadAll(stdout)
retStr = string(retb)
}
return retStr, err
}
func MaestroCommandExec(cmd *exec.Cmd, output chan string) (exitCode int) {
cmdOut, err := cmd.StdoutPipe()
if err != nil {
lg.DebugError(err)
}
cmdErr, err := cmd.StderrPipe()
if err != nil {
lg.DebugError(err)
}
scannerOut := bufio.NewScanner(cmdOut)
scannerErr := bufio.NewScanner(cmdErr)
go func() {
for scannerOut.Scan() {
output <- scannerOut.Text()
}
for scannerErr.Scan() {
output <- scannerErr.Text()
}
close(output)
}()
if err := cmd.Start(); err != nil {
lg.DebugError(err)
}
if err := cmd.Wait(); err != nil {
if err != nil {
lg.DebugError(err)
}
if exitError, ok := err.(*exec.ExitError); ok {
waitStatus := exitError.Sys().(syscall.WaitStatus)
exitCode = waitStatus.ExitStatus()
}
}
return
}
func (c *Communicator) Start(remote *packer.RemoteCmd) error {
var cmd *exec.Cmd
if c.Config.Pty {
cmd = exec.Command("docker", "exec", "-i", "-t", c.ContainerId, "/bin/sh", "-c", fmt.Sprintf("(%s)", remote.Command))
} else {
cmd = exec.Command("docker", "exec", "-i", c.ContainerId, "/bin/sh", "-c", fmt.Sprintf("(%s)", remote.Command))
}
var (
stdin_w io.WriteCloser
err error
)
stdin_w, err = cmd.StdinPipe()
if err != nil {
return err
}
stderr_r, err := cmd.StderrPipe()
if err != nil {
return err
}
stdout_r, err := cmd.StdoutPipe()
if err != nil {
return err
}
// Run the actual command in a goroutine so that Start doesn't block
go c.run(cmd, remote, stdin_w, stdout_r, stderr_r)
return nil
}
// RunCommandWithStdoutStderr execs a command and returns its output.
func RunCommandWithStdoutStderr(cmd *exec.Cmd) (bytes.Buffer, bytes.Buffer, error) {
var stdout, stderr bytes.Buffer
stderrPipe, err := cmd.StderrPipe()
stdoutPipe, err := cmd.StdoutPipe()
cmd.Env = os.Environ()
if err != nil {
fmt.Println("error at io pipes")
}
err = cmd.Start()
if err != nil {
fmt.Println("error at command start")
}
go func() {
io.Copy(&stdout, stdoutPipe)
fmt.Println(stdout.String())
}()
go func() {
io.Copy(&stderr, stderrPipe)
fmt.Println(stderr.String())
}()
time.Sleep(2000 * time.Millisecond)
err = cmd.Wait()
if err != nil {
fmt.Println("error at command wait")
}
return stdout, stderr, err
}
func execCommand(cmd *exec.Cmd, prefix string, name string) (bool, *string, *string) {
out, err := cmd.StdoutPipe()
outE, errE := cmd.StderrPipe()
if err != nil {
log.Warnf("[command] %s err: %s", prefix, out)
log.Warnf("[command] %s err: %s", prefix, err)
return false, nil, nil
}
if errE != nil {
log.Warnf("[command] %s err: %s", prefix, outE)
log.Warnf("[command] %s err: %s", prefix, errE)
return false, nil, nil
}
err = cmd.Start()
if err != nil {
log.Warnf("[command] %s err: %s", prefix, err)
return false, nil, nil
}
outResult := copyStream(out, prefix, name)
errResult := copyStream(outE, prefix, name)
err = cmd.Wait()
if err != nil {
log.Warnf("[command] %s err: %s", prefix, err)
return false, &outResult, &errResult
}
return true, &outResult, &errResult
}
func attachCmd(cmd *exec.Cmd, stdout, stderr io.Writer, stdin io.Reader) chan error {
errCh := make(chan error)
stdinIn, err := cmd.StdinPipe()
if err != nil {
panic(err)
}
stdoutOut, err := cmd.StdoutPipe()
if err != nil {
panic(err)
}
stderrOut, err := cmd.StderrPipe()
if err != nil {
panic(err)
}
go func() {
_, e := io.Copy(stdinIn, stdin)
errCh <- e
}()
go func() {
_, e := io.Copy(stdout, stdoutOut)
errCh <- e
}()
go func() {
_, e := io.Copy(stderr, stderrOut)
errCh <- e
}()
return errCh
}
func ExecCmd(path string, arg1 string, args ...string) (string, error) {
var cmd *exec.Cmd
argsNew := make([]string, len(args))
for i, a := range args {
argsNew[i] = a
}
cmd = exec.Command(arg1, argsNew...)
cmd.Dir = path
// cmd.stdin = os.Stdin
stderr, err := cmd.StderrPipe()
if err != nil {
log.Fatal("stderr err %v", err)
}
stdout, err := cmd.StdoutPipe()
if err != nil {
log.Fatalf("stdout err %v", err)
}
var retStr string
err = cmd.Start()
if err != nil {
retb, _ := ioutil.ReadAll(stderr)
retStr = string(retb)
// stdoutReader.ReadRune()
} else {
retb, _ := ioutil.ReadAll(stdout)
retStr = string(retb)
}
return retStr, err
}
func LogCommand(cmd *exec.Cmd, asDebug bool) {
logrus.WithField("command", cmd.Args).Debugf("running command")
stdout, err := cmd.StdoutPipe()
if err != nil {
return
}
stderr, err := cmd.StderrPipe()
if err != nil {
return
}
go func() {
in := bufio.NewScanner(stdout)
for in.Scan() {
if asDebug {
logrus.Debugf(in.Text())
} else {
logrus.Infof(in.Text())
}
}
}()
go func() {
in := bufio.NewScanner(stderr)
for in.Scan() {
logrus.Debugf(in.Text())
}
}()
}
func (t *task) logCmd(cmd *exec.Cmd) {
stderr, _ := cmd.StderrPipe()
stdout, _ := cmd.StdoutPipe()
go t.logPipe(bufio.NewScanner(stderr))
go t.logPipe(bufio.NewScanner(stdout))
}
// execute one command
func execCommand(cmd *exec.Cmd, mes message.ToWork, reportChan chan message.Report) {
logger.Infof("Start executing one command : %v", cmd)
go func() {
stdout, errPipe1 := cmd.StdoutPipe()
stderr, errPipe2 := cmd.StderrPipe()
errCmd := cmd.Start()
hasErr, errMes := hasError(errPipe1, errPipe2, errCmd)
if hasErr {
reportChan <- message.Report{mes.JobId, message.FAILED, errMes}
} else {
multi := io.MultiReader(stdout, stderr)
in := bufio.NewScanner(multi)
// todo see if a more efficient way is possible
buf := []string{}
for in.Scan() {
s := in.Text()
buf = append(buf, s)
if len(buf) > 4 {
buf = consumeBuffer(buf, mes.JobId, reportChan)
}
}
// finish the rest of the buffer
consumeBuffer(buf, mes.JobId, reportChan)
if inErr := in.Err(); inErr != nil {
reportChan <- message.Report{mes.JobId, message.FAILED, []string{inErr.Error()}}
} else {
pushEndReport(cmd, mes.JobId, reportChan)
}
}
}()
}
func CmdStream(cmd *exec.Cmd) (io.Reader, error) {
stdout, err := cmd.StdoutPipe()
if err != nil {
return nil, err
}
stderr, err := cmd.StderrPipe()
if err != nil {
return nil, err
}
pipeR, pipeW := io.Pipe()
go func() {
_, err := io.Copy(pipeW, stdout)
if err != nil {
pipeW.CloseWithError(err)
}
errText, e := ioutil.ReadAll(stderr)
if e != nil {
errText = []byte("(...couldn't fetch stderr: " + e.Error() + ")")
}
if err := cmd.Wait(); err != nil {
// FIXME: can this block if stderr outputs more than the size of StderrPipe()'s buffer?
pipeW.CloseWithError(errors.New(err.Error() + ": " + string(errText)))
} else {
pipeW.Close()
}
}()
if err := cmd.Start(); err != nil {
return nil, err
}
return pipeR, nil
}
// Connect stderr/stdout of future child to logger and background copy jobs.
func connectOutputs(cmd *exec.Cmd, logger io.Writer, wg *sync.WaitGroup) error {
if !opts.NoPipeStdout {
stdout, err := cmd.StdoutPipe()
if err != nil {
return &StartupError{"connecting stdout", err}
}
if opts.WrapNagiosPlugin {
firstbytes = NewCapWriter(8192)
stdout := io.TeeReader(stdout, firstbytes)
logStream(stdout, logger, wg)
} else {
logStream(stdout, logger, wg)
}
} else if opts.WrapNagiosPlugin {
stdout, err := cmd.StdoutPipe()
if err != nil {
return &StartupError{"connecting stdout", err}
}
firstbytes = NewCapWriter(8192)
logStream(stdout, firstbytes, wg)
}
if !opts.NoPipeStderr {
stderr, err := cmd.StderrPipe()
if err != nil {
return &StartupError{"connecting stderr", err}
}
logStream(stderr, logger, wg)
}
return nil
}
func callCont(c *exec.Cmd, cont func(io.Reader) error) error {
_, callerFile, callerLine, _ := runtime.Caller(1)
log.Printf("%15s:%.3d -> %s", path.Base(callerFile), callerLine, strings.Join(c.Args, " "))
var reader io.Reader
var err error
if cont != nil {
reader, err = c.StdoutPipe()
if err != nil {
return err
}
}
stderr, err := c.StderrPipe()
if err != nil {
return err
}
if err = c.Start(); err != nil {
return err
}
if cont != nil {
if err = cont(reader); err != nil {
return err
}
}
buffer := bytes.NewBuffer(nil)
buffer.ReadFrom(stderr)
if buffer.Len() != 0 {
log.Print("Command had output on stderr.\n Cmd: ", strings.Join(c.Args, " "), "\nstderr: ", buffer)
}
return c.Wait()
}
func runDocker(cmd *exec.Cmd) {
stdout, err := cmd.StdoutPipe()
if err != nil {
SendError(err, "Failed to get docker piped stdout", nil)
Logger.Println(err)
Logger.Println("Cannotget docker piped stdout")
}
stderr, err := cmd.StderrPipe()
if err != nil {
SendError(err, "Failed to get docker piped stdout", nil)
Logger.Println(err)
Logger.Println("Cannotget docker piped stdout")
}
//open file to log docker logs
dockerLog := path.Join(LogDir, DockerLogFileName)
f, err := os.OpenFile(dockerLog, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0666)
if err != nil {
SendError(err, "Failed to set docker log file", nil)
Logger.Println(err)
Logger.Println("Cannot set docker log to", dockerLog)
} else {
go io.Copy(f, stdout)
go io.Copy(f, stderr)
defer f.Close()
}
Logger.Println("Starting docker daemon:", cmd.Args)
if err := cmd.Start(); err != nil {
SendError(err, "Failed to start docker daemon", nil)
Logger.Println("Cannot start docker daemon:", err)
}
DockerProcess = cmd.Process
Logger.Printf("Docker daemon (PID:%d) has been started", DockerProcess.Pid)
syscall.Setpriority(syscall.PRIO_PROCESS, DockerProcess.Pid, RenicePriority)
exit_renice := make(chan int)
go decreaseDockerChildProcessPriority(exit_renice)
if err := cmd.Wait(); err != nil {
Logger.Println("Docker daemon died with error:", err)
out, tailErr := exec.Command("tail", "-n", "10", dockerLog).Output()
if tailErr != nil {
SendError(tailErr, "Failed to tail docker logs when docker terminates unexpectedly", nil)
Logger.Printf("Failed to tail docker logs when docker terminates unexpectedly: %s", err)
SendError(err, "Docker daemon terminates unexpectedly", nil)
} else {
extra := map[string]interface{}{"docker-log": string(out)}
SendError(err, "Docker daemon terminates unexpectedly", extra)
Logger.Printf("\n=======DOCKER LOGS BEGIN========\n%s=======DOCKER LOGS END========\n", string(out))
}
} else {
Logger.Print("Docker daemon exited")
}
exit_renice <- 1
DockerProcess = nil
}
// Run runs the command and returns a channel of output lines, errors and result of cmd.Wait
func Run(cmd *exec.Cmd, lines chan string) (error, error) {
stdout, err := cmd.StdoutPipe()
if err != nil {
return nil, err
}
stderr, err := cmd.StderrPipe()
if err != nil {
return nil, err
}
err = cmd.Start()
if err != nil {
return nil, err
}
var wg sync.WaitGroup
errCh := make(chan error, 2)
wg.Add(2)
go tailReader(bufio.NewReader(stdout), lines, errCh, &wg)
go tailReader(bufio.NewReader(stderr), lines, errCh, &wg)
wg.Wait()
select {
case err := <-errCh:
return nil, err
default:
}
return cmd.Wait(), nil
}