Package exec

Variables

ErrExecutableNotFound is returned if the executable is not found.

var ErrExecutableNotFound = osexec.ErrNotFound

type Cmd ¶

Cmd is an interface that presents an API that is very similar to Cmd from os/exec. As more functionality is needed, this can grow. Since Cmd is a struct, we will have to replace fields with get/set method pairs.

type Cmd interface {
    // Run runs the command to the completion.
    Run() error
    // CombinedOutput runs the command and returns its combined standard output
    // and standard error. This follows the pattern of package os/exec.
    CombinedOutput() ([]byte, error)
    // Output runs the command and returns standard output, but not standard err
    Output() ([]byte, error)
    SetDir(dir string)
    SetStdin(in io.Reader)
    SetStdout(out io.Writer)
    SetStderr(out io.Writer)
    SetEnv(env []string)

    // StdoutPipe and StderrPipe for getting the process' Stdout and Stderr as
    // Readers
    StdoutPipe() (io.ReadCloser, error)
    StderrPipe() (io.ReadCloser, error)

    // Start and Wait are for running a process non-blocking
    Start() error
    Wait() error

    // Stops the command by sending SIGTERM. It is not guaranteed the
    // process will stop before this function returns. If the process is not
    // responding, an internal timer function will send a SIGKILL to force
    // terminate after 10 seconds.
    Stop()
}

type CodeExitError ¶

CodeExitError is an implementation of ExitError consisting of an error object and an exit code (the upper bits of os.exec.ExitStatus).

type CodeExitError struct {
    Err  error
    Code int
}

func (CodeExitError) Error ¶

func (e CodeExitError) Error() string

func (CodeExitError) ExitStatus ¶

func (e CodeExitError) ExitStatus() int

ExitStatus is for checking the error code

func (CodeExitError) Exited ¶

func (e CodeExitError) Exited() bool

Exited is to check if the process has finished

func (CodeExitError) String ¶

func (e CodeExitError) String() string

type ExitError ¶

ExitError is an interface that presents an API similar to os.ProcessState, which is what ExitError from os/exec is. This is designed to make testing a bit easier and probably loses some of the cross-platform properties of the underlying library.

type ExitError interface {
    String() string
    Error() string
    Exited() bool
    ExitStatus() int
}

type ExitErrorWrapper ¶

ExitErrorWrapper is an implementation of ExitError in terms of os/exec ExitError. Note: standard exec.ExitError is type *os.ProcessState, which already implements Exited().

type ExitErrorWrapper struct {
    *osexec.ExitError
}

func (ExitErrorWrapper) ExitStatus ¶

func (eew ExitErrorWrapper) ExitStatus() int

ExitStatus is part of the ExitError interface.

type Interface ¶

Interface is an interface that presents a subset of the os/exec API. Use this when you want to inject fakeable/mockable exec behavior.

type Interface interface {
    // Command returns a Cmd instance which can be used to run a single command.
    // This follows the pattern of package os/exec.
    Command(cmd string, args ...string) Cmd

    // CommandContext returns a Cmd instance which can be used to run a single command.
    //
    // The provided context is used to kill the process if the context becomes done
    // before the command completes on its own. For example, a timeout can be set in
    // the context.
    CommandContext(ctx context.Context, cmd string, args ...string) Cmd

    // LookPath wraps os/exec.LookPath
    LookPath(file string) (string, error)
}

func New ¶

func New() Interface

New returns a new Interface which will os/exec to run commands.

exec := exec.New()

cmd := exec.Command("echo", "Bonjour!")
buff := bytes.Buffer{}
cmd.SetStdout(&buff)
if err := cmd.Run(); err != nil {
    panic(err)
}
fmt.Println(buff.String())

Bonjour!

cmd := exec.New().Command("/bin/sh", "-c", "echo 'We can read from stderr via pipe!' >&2")

stderrPipe, err := cmd.StderrPipe()
if err != nil {
    panic(err)
}

stderr := make(chan []byte)
go func() {
    b, err := ioutil.ReadAll(stderrPipe)
    if err != nil {
        panic(err)
    }
    stderr <- b
}()

if err := cmd.Start(); err != nil {
    panic(err)
}

received := <-stderr

if err := cmd.Wait(); err != nil {
    panic(err)
}

fmt.Println(string(received))

We can read from stderr via pipe!

Subdirectories