exec: new API, replace Run with Command

This removes exec.Run and replaces exec.Cmd with a
new implementation. The new exec.Cmd represents
both a currently-running command and also a command
being prepared. It has a good zero value.

You can Start + Wait on a Cmd, or simply Run it.
Start (and Run) deal with copying stdout, stdin,
and stderr between the Cmd's io.Readers and
io.Writers.

There are convenience methods to capture a command's
stdout and/or stderr.

R=r, n13m3y3r, rsc, gustavo, alex.brainman, dsymonds, r, adg, duzy.chan, mike.rosset, kevlar
CC=golang-dev
https://golang.org/cl/4552052

1 files changed, 228 insertions, 148 deletions

diff --git a/src/pkg/exec/exec.go b/src/pkg/exec/exec.go
index 043f847283..a724ad0b1c 100644
--- a/src/pkg/exec/exec.go
+++ b/src/pkg/exec/exec.go
@@ -7,33 +7,13 @@
 // adjustments.
 package exec
 
-// BUG(r): This package should be made even easier to use or merged into os.
-
 import (
+	"bytes"
+	"io"
 	"os"
 	"strconv"
 )
 
-// Arguments to Run.
-const (
-	DevNull = iota
-	PassThrough
-	Pipe
-	MergeWithStdout
-)
-
-// A Cmd represents a running command.
-// Stdin, Stdout, and Stderr are Files representing pipes
-// connected to the running command's standard input, output, and error,
-// or else nil, depending on the arguments to Run.
-// Process represents the underlying operating system process.
-type Cmd struct {
-	Stdin   *os.File
-	Stdout  *os.File
-	Stderr  *os.File
-	Process *os.Process
-}
-
 // PathError records the name of a binary that was not
 // found on the current $PATH.
 type PathError struct {
@@ -44,161 +24,261 @@ func (e *PathError) String() string {
 	return "command " + strconv.Quote(e.Name) + " not found in $PATH"
 }
 
-// Given mode (DevNull, etc), return file for child
-// and file to record in Cmd structure.
-func modeToFiles(mode, fd int) (*os.File, *os.File, os.Error) {
-	switch mode {
-	case DevNull:
-		rw := os.O_WRONLY
-		if fd == 0 {
-			rw = os.O_RDONLY
-		}
-		f, err := os.OpenFile(os.DevNull, rw, 0)
-		return f, nil, err
-	case PassThrough:
-		switch fd {
-		case 0:
-			return os.Stdin, nil, nil
-		case 1:
-			return os.Stdout, nil, nil
-		case 2:
-			return os.Stderr, nil, nil
-		}
-	case Pipe:
-		r, w, err := os.Pipe()
-		if err != nil {
-			return nil, nil, err
-		}
-		if fd == 0 {
-			return r, w, nil
-		}
-		return w, r, nil
-	}
-	return nil, nil, os.EINVAL
+// Cmd represents an external command being prepared or run.
+type Cmd struct {
+	// Path is the path of the command to run.
+	//
+	// This is the only field that must be set to a non-zero
+	// value.
+	Path string
+
+	// Args is the command line arguments, including the command as Args[0].
+	// If Args is empty, Run uses {Path}.
+	// 
+	// In typical use, both Path and Args are set by calling Command.
+	Args []string
+
+	// Env specifies the environment of the process.
+	// If Env is nil, Run uses the current process's environment.
+	Env []string
+
+	// Dir specifies the working directory of the command.
+	// If Dir is the empty string, Run runs the command in the
+	// process's current directory.
+	Dir string
+
+	// Stdin specifies the process's standard input.
+	// If Stdin is nil, the process reads from DevNull.
+	Stdin io.Reader
+
+	// Stdout and Stderr specify the process's standard output and error.
+	//
+	// If either is nil, Run connects the
+	// corresponding file descriptor to /dev/null.
+	//
+	// If Stdout and Stderr are are the same writer, at most one
+	// goroutine at a time will call Write.
+	Stdout io.Writer
+	Stderr io.Writer
+
+	err             os.Error // last error (from LookPath, stdin, stdout, stderr)
+	process         *os.Process
+	childFiles      []*os.File
+	closeAfterStart []*os.File
+	closeAfterWait  []*os.File
+	goroutine       []func() os.Error
+	errch           chan os.Error // one send per goroutine
 }
 
-// Run starts the named binary running with
-// arguments argv and environment envv.
-// If the dir argument is not empty, the child changes
-// into the directory before executing the binary.
-// It returns a pointer to a new Cmd representing
-// the command or an error.
+// Command returns the Cmd struct to execute the named program with
+// the given arguments.
 //
-// The arguments stdin, stdout, and stderr
-// specify how to handle standard input, output, and error.
-// The choices are DevNull (connect to /dev/null),
-// PassThrough (connect to the current process's standard stream),
-// Pipe (connect to an operating system pipe), and
-// MergeWithStdout (only for standard error; use the same
-// file descriptor as was used for standard output).
-// If an argument is Pipe, then the corresponding field (Stdin, Stdout, Stderr)
-// of the returned Cmd is the other end of the pipe.
-// Otherwise the field in Cmd is nil.
-func Run(name string, argv, envv []string, dir string, stdin, stdout, stderr int) (c *Cmd, err os.Error) {
-	c = new(Cmd)
-	var fd [3]*os.File
+// It sets Path and Args in the returned structure and zeroes the
+// other fields.
+//
+// If name contains no path separators, Command uses LookPath to
+// resolve the path to a complete name if possible. Otherwise it uses
+// name directly.
+//
+// The returned Cmd's Args is constructed from the command name
+// followed by the elements of arg, so arg should not include the
+// command name itself. For example, Command("echo", "hello")
+func Command(name string, arg ...string) *Cmd {
+	aname, err := LookPath(name)
+	if err != nil {
+		aname = name
+	}
+	return &Cmd{
+		Path: aname,
+		Args: append([]string{name}, arg...),
+		err:  err,
+	}
+}
+
+// interfaceEqual protects against panics from doing equality tests on
+// two interface with non-comparable underlying types
+func interfaceEqual(a, b interface{}) bool {
+	defer func() {
+		recover()
+	}()
+	return a == b
+}
 
-	if fd[0], c.Stdin, err = modeToFiles(stdin, 0); err != nil {
-		goto Error
+func (c *Cmd) envv() []string {
+	if c.Env != nil {
+		return c.Env
 	}
-	if fd[1], c.Stdout, err = modeToFiles(stdout, 1); err != nil {
-		goto Error
+	return os.Environ()
+}
+
+func (c *Cmd) argv() []string {
+	if len(c.Args) > 0 {
+		return c.Args
 	}
-	if stderr == MergeWithStdout {
-		fd[2] = fd[1]
-	} else if fd[2], c.Stderr, err = modeToFiles(stderr, 2); err != nil {
-		goto Error
+	return []string{c.Path}
+}
+
+func (c *Cmd) stdin() (f *os.File, err os.Error) {
+	if c.Stdin == nil {
+		f, err = os.Open(os.DevNull)
+		c.closeAfterStart = append(c.closeAfterStart, f)
+		return
 	}
 
-	// Run command.
-	c.Process, err = os.StartProcess(name, argv, &os.ProcAttr{Dir: dir, Files: fd[:], Env: envv})
-	if err != nil {
-		goto Error
+	if f, ok := c.Stdin.(*os.File); ok {
+		return f, nil
 	}
-	if fd[0] != os.Stdin {
-		fd[0].Close()
+
+	pr, pw, err := os.Pipe()
+	if err != nil {
+		return
 	}
-	if fd[1] != os.Stdout {
-		fd[1].Close()
+
+	c.closeAfterStart = append(c.closeAfterStart, pr)
+	c.closeAfterWait = append(c.closeAfterWait, pw)
+	c.goroutine = append(c.goroutine, func() os.Error {
+		_, err := io.Copy(pw, c.Stdin)
+		if err1 := pw.Close(); err == nil {
+			err = err1
+		}
+		return err
+	})
+	return pr, nil
+}
+
+func (c *Cmd) stdout() (f *os.File, err os.Error) {
+	return c.writerDescriptor(c.Stdout)
+}
+
+func (c *Cmd) stderr() (f *os.File, err os.Error) {
+	if c.Stderr != nil && interfaceEqual(c.Stderr, c.Stdout) {
+		return c.childFiles[1], nil
 	}
-	if fd[2] != os.Stderr && fd[2] != fd[1] {
-		fd[2].Close()
+	return c.writerDescriptor(c.Stderr)
+}
+
+func (c *Cmd) writerDescriptor(w io.Writer) (f *os.File, err os.Error) {
+	if w == nil {
+		f, err = os.OpenFile(os.DevNull, os.O_WRONLY, 0)
+		c.closeAfterStart = append(c.closeAfterStart, f)
+		return
 	}
-	return c, nil
 
-Error:
-	if fd[0] != os.Stdin && fd[0] != nil {
-		fd[0].Close()
+	if f, ok := w.(*os.File); ok {
+		return f, nil
 	}
-	if fd[1] != os.Stdout && fd[1] != nil {
-		fd[1].Close()
+
+	pr, pw, err := os.Pipe()
+	if err != nil {
+		return
 	}
-	if fd[2] != os.Stderr && fd[2] != nil && fd[2] != fd[1] {
-		fd[2].Close()
+
+	c.closeAfterStart = append(c.closeAfterStart, pw)
+	c.closeAfterWait = append(c.closeAfterWait, pr)
+	c.goroutine = append(c.goroutine, func() os.Error {
+		_, err := io.Copy(w, pr)
+		return err
+	})
+	return pw, nil
+}
+
+// Run runs the specified command and waits for it to complete.
+//
+// The returned error is nil if the command runs, has no problems
+// copying stdin, stdout, and stderr, and exits with a zero exit
+// status.
+//
+// If the command fails to run or doesn't complete successfully, the
+// error is of type *os.Waitmsg. Other error types may be
+// returned for I/O problems.
+func (c *Cmd) Run() os.Error {
+	if err := c.Start(); err != nil {
+		return err
 	}
-	if c.Stdin != nil {
-		c.Stdin.Close()
+	return c.Wait()
+}
+
+func (c *Cmd) Start() os.Error {
+	if c.err != nil {
+		return c.err
 	}
-	if c.Stdout != nil {
-		c.Stdout.Close()
+	if c.process != nil {
+		return os.NewError("exec: already started")
 	}
-	if c.Stderr != nil {
-		c.Stderr.Close()
+
+	type F func(*Cmd) (*os.File, os.Error)
+	for _, setupFd := range []F{(*Cmd).stdin, (*Cmd).stdout, (*Cmd).stderr} {
+		fd, err := setupFd(c)
+		if err != nil {
+			return err
+		}
+		c.childFiles = append(c.childFiles, fd)
 	}
-	if c.Process != nil {
-		c.Process.Release()
+
+	var err os.Error
+	c.process, err = os.StartProcess(c.Path, c.argv(), &os.ProcAttr{
+		Dir:   c.Dir,
+		Files: c.childFiles,
+		Env:   c.envv(),
+	})
+	if err != nil {
+		return err
 	}
-	return nil, err
-}
 
-// Wait waits for the running command c,
-// returning the Waitmsg returned when the process exits.
-// The options are passed to the process's Wait method.
-// Setting options to 0 waits for c to exit;
-// other options cause Wait to return for other
-// process events; see package os for details.
-func (c *Cmd) Wait(options int) (*os.Waitmsg, os.Error) {
-	if c.Process == nil {
-		return nil, os.ErrorString("exec: invalid use of Cmd.Wait")
+	for _, fd := range c.closeAfterStart {
+		fd.Close()
 	}
-	w, err := c.Process.Wait(options)
-	if w != nil && (w.Exited() || w.Signaled()) {
-		c.Process.Release()
-		c.Process = nil
+
+	c.errch = make(chan os.Error, len(c.goroutine))
+	for _, fn := range c.goroutine {
+		go func(fn func() os.Error) {
+			c.errch <- fn()
+		}(fn)
 	}
-	return w, err
+
+	return nil
 }
 
-// Close waits for the running command c to exit,
-// if it hasn't already, and then closes the non-nil file descriptors
-// c.Stdin, c.Stdout, and c.Stderr.
-func (c *Cmd) Close() os.Error {
-	if c.Process != nil {
-		// Loop on interrupt, but
-		// ignore other errors -- maybe
-		// caller has already waited for pid.
-		_, err := c.Wait(0)
-		for err == os.EINTR {
-			_, err = c.Wait(0)
-		}
+func (c *Cmd) Wait() os.Error {
+	if c.process == nil {
+		return os.NewError("exec: not started")
 	}
+	msg, err := c.process.Wait(0)
 
-	// Close the FDs that are still open.
-	var err os.Error
-	if c.Stdin != nil && c.Stdin.Fd() >= 0 {
-		if err1 := c.Stdin.Close(); err1 != nil {
-			err = err1
+	var copyError os.Error
+	for _ = range c.goroutine {
+		if err := <-c.errch; err != nil && copyError == nil {
+			copyError = err
 		}
 	}
-	if c.Stdout != nil && c.Stdout.Fd() >= 0 {
-		if err1 := c.Stdout.Close(); err1 != nil && err != nil {
-			err = err1
-		}
+
+	for _, fd := range c.closeAfterWait {
+		fd.Close()
 	}
-	if c.Stderr != nil && c.Stderr != c.Stdout && c.Stderr.Fd() >= 0 {
-		if err1 := c.Stderr.Close(); err1 != nil && err != nil {
-			err = err1
-		}
+
+	if err != nil {
+		return err
+	} else if !msg.Exited() || msg.ExitStatus() != 0 {
+		return msg
 	}
-	return err
+
+	return copyError
+}
+
+// Output runs the command and returns its standard output.
+func (c *Cmd) Output() ([]byte, os.Error) {
+	var b bytes.Buffer
+	c.Stdout = &b
+	err := c.Run()
+	return b.Bytes(), err
+}
+
+// CombinedOutput runs the command and returns its combined standard
+// output and standard error.
+func (c *Cmd) CombinedOutput() ([]byte, os.Error) {
+	var b bytes.Buffer
+	c.Stdout = &b
+	c.Stderr = &b
+	err := c.Run()
+	return b.Bytes(), err
 }