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 (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()
}
func printlog(c2 *exec.Cmd) {
stdout, err := c2.StdoutPipe()
if err != nil {
fmt.Println(err.Error())
os.Exit(1)
}
if err := c2.Start(); err != nil {
fmt.Println("Command error:", err.Error())
os.Exit(1)
}
in := bufio.NewScanner(stdout)
fmt.Println(in)
for in.Scan() {
fmt.Println(in.Text())
}
if err := in.Err(); err != nil {
fmt.Println("Err:", err.Error())
os.Exit(1)
}
}
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
}
// 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 WrapinMKV(uuidpath string, audioin chan []byte, audio bool) {
var ffmpeg *exec.Cmd
if audio {
ffmpeg = exec.Command("ffmpeg", "-f", "mjpeg", "-i", uuidpath, "-f", "s32be", "-ac", "2", "-ar", "44100", "-i", "pipe:0", "-f", "matroska", "-codec", "copy", "pipe:1")
} else {
ffmpeg = exec.Command("ffmpeg", "-f", "mjpeg", "-i", uuidpath, "-f", "matroska", "-codec", "copy", "pipe:1")
}
ffmpegstdout, err := ffmpeg.StdoutPipe()
if err != nil {
log.Fatalf("Unable to setup pipes for ffmpeg (stdout)")
}
ffmpeg.Stderr = os.Stderr
audiofile, err := ffmpeg.StdinPipe()
go DumpChanToFile(audioin, audiofile)
ffmpeg.Start()
for {
_, err := io.Copy(os.Stdout, ffmpegstdout)
if err != nil {
log.Fatalf("unable to read to stdout: %s", err.Error())
}
}
}
// 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
}
// 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
}
// 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 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 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
}
// 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 execCommand(cmd *exec.Cmd) error {
cmdReader, err := cmd.StdoutPipe()
if err != nil {
fmt.Fprintln(os.Stderr, "Error creating StdoutPipe for Cmd", err)
return err
}
scanner := bufio.NewScanner(cmdReader)
go func() {
for scanner.Scan() {
fmt.Printf("docker build out | %s\n", scanner.Text())
}
}()
var stderr bytes.Buffer
cmd.Stdout = os.Stdout
cmd.Stderr = &stderr
err = cmd.Start()
if err != nil {
fmt.Printf("docker build out | %s\n", stderr.String())
return err
}
err = cmd.Wait()
if err != nil {
fmt.Printf("docker build out | %s\n", stderr.String())
return err
}
return err
}
// 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 writeGitRepositoryArchive(w io.Writer, path string, ref GitCommitRef) error {
var cmd *exec.Cmd
// TODO: Stream as tar with gzip
if ref == EmptyGitCommitRef {
cmd = exec.Command("/usr/bin/git", "archive", "--format", "zip", "master")
} else {
cmd = exec.Command("/usr/bin/git", "archive", "--format", "zip", string(ref))
}
cmd.Env = []string{}
cmd.Dir = path
var stderr bytes.Buffer
cmd.Stderr = utils.LimitWriter(&stderr, 20*1024)
stdout, err := cmd.StdoutPipe()
if err != nil {
return err
}
if err := cmd.Start(); err != nil {
return err
}
io.Copy(w, stdout)
if err := cmd.Wait(); err != nil {
return errors.New(fmt.Sprintf("Failed to archive repository: %s\n", err.Error()) + stderr.String())
}
return nil
}
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 (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
}
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 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
}
// 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 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 RunAndListen(cmd *exec.Cmd, fn func(s string)) error {
var stderr bytes.Buffer
cmd.Stderr = &stderr
r, err := cmd.StdoutPipe()
if err != nil {
return fmt.Errorf("%s: %s", err, stderr.String())
}
scanner := bufio.NewScanner(r)
go func() {
for scanner.Scan() {
fn(scanner.Text())
}
}()
err = cmd.Start()
if err != nil {
return fmt.Errorf("%s: %s", err, stderr.String())
}
err = cmd.Wait()
if err != nil {
return fmt.Errorf("%s: %s", err, stderr.String())
}
return nil
}
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))
}
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
}
func source(dir, from, to string) <-chan string {
var cmd *exec.Cmd
if to == "" {
cmd = exec.Command("git", "-C", dir, "log", `--pretty=format:hash: %H%n-----%nauthor: %an <%ae>%n-----%nrawSubject: %s%n-----%nrawBody: %b%n-----%nEND-COMMIT%n`, from)
} else {
cmd = exec.Command("git", "-C", dir, "log", `--pretty=format:hash: %H%n-----%nauthor: %an <%ae>%n-----%nrawSubject: %s%n-----%nrawBody: %b%n-----%nEND-COMMIT%n`, to+".."+from)
}
outputChannel := make(chan string)
output, err := cmd.StdoutPipe()
if err != nil {
panic(err)
}
err = cmd.Start()
if err != nil {
log.Fatal(err)
}
go func() {
scanner := bufio.NewScanner(output)
for scanner.Scan() {
outputChannel <- scanner.Text()
}
defer output.Close()
close(outputChannel)
if err := scanner.Err(); err != nil {
log.Fatal(err)
}
}()
return outputChannel
}
// 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
}
// newConn executes the given command, returning an io.ReadWriteCloser attached to its stdout/stdin.
// The Cmd's Stdout/Stdin/Stderr are modified, but everything else (env, cwd, etc) is left intact.
// Takes ownership of cmd -- callers may not modify it after passing it to NewConn.
func newConn(cmd *exec.Cmd) (io.ReadWriteCloser, error) {
cmd.Stderr = os.Stderr
stdout, err := cmd.StdoutPipe()
if err != nil {
return nil, err
}
stdin, err := cmd.StdinPipe()
if err != nil {
return nil, err
}
conn := &conn{
cmd: cmd,
stdout: stdout,
stdin: stdin,
done: make(chan bool),
}
if err := cmd.Start(); err != nil {
return nil, err
}
go func() {
conn.err = cmd.Wait()
close(conn.done)
}()
return conn, nil
}