Package exec provides an injectable interface and implementations for running commands.



    This section is empty.


    View Source
    var ErrExecutableNotFound = osexec.ErrNotFound

      ErrExecutableNotFound is returned if the executable is not found.


      This section is empty.


      type Cmd

      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)
      	// 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.

        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.

        func InitFakeCmd

        func InitFakeCmd(fake *FakeCmd, cmd string, args ...string) Cmd

        type CodeExitError

        type CodeExitError struct {
        	Err  error
        	Code int

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

          func (CodeExitError) Error

          func (e CodeExitError) Error() string

          func (CodeExitError) ExitStatus

          func (e CodeExitError) ExitStatus() int

          func (CodeExitError) Exited

          func (e CodeExitError) Exited() bool

          func (CodeExitError) String

          func (e CodeExitError) String() string

          type ExitError

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

            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 ExitErrorWrapper

            type ExitErrorWrapper struct {

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

              func (ExitErrorWrapper) ExitStatus

              func (eew ExitErrorWrapper) ExitStatus() int

                ExitStatus is part of the ExitError interface.

                type FakeCmd

                type FakeCmd struct {
                	Argv                 []string
                	CombinedOutputScript []FakeCombinedOutputAction
                	CombinedOutputCalls  int
                	CombinedOutputLog    [][]string
                	RunScript            []FakeRunAction
                	RunCalls             int
                	RunLog               [][]string
                	Dirs                 []string
                	Stdin                io.Reader
                	Stdout               io.Writer
                	Stderr               io.Writer

                  A simple scripted Cmd type.

                  func (*FakeCmd) CombinedOutput

                  func (fake *FakeCmd) CombinedOutput() ([]byte, error)

                  func (*FakeCmd) Output

                  func (fake *FakeCmd) Output() ([]byte, error)

                  func (*FakeCmd) Run

                  func (fake *FakeCmd) Run() error

                  func (*FakeCmd) SetDir

                  func (fake *FakeCmd) SetDir(dir string)

                  func (*FakeCmd) SetStderr

                  func (fake *FakeCmd) SetStderr(out io.Writer)

                  func (*FakeCmd) SetStdin

                  func (fake *FakeCmd) SetStdin(in io.Reader)

                  func (*FakeCmd) SetStdout

                  func (fake *FakeCmd) SetStdout(out io.Writer)

                  func (*FakeCmd) Stop

                  func (fake *FakeCmd) Stop()

                  type FakeCombinedOutputAction

                  type FakeCombinedOutputAction func() ([]byte, error)

                  type FakeCommandAction

                  type FakeCommandAction func(cmd string, args ...string) Cmd

                  type FakeExec

                  type FakeExec struct {
                  	CommandScript []FakeCommandAction
                  	CommandCalls  int
                  	LookPathFunc  func(string) (string, error)

                    A simple scripted Interface type.

                    func (*FakeExec) Command

                    func (fake *FakeExec) Command(cmd string, args ...string) Cmd

                    func (*FakeExec) LookPath

                    func (fake *FakeExec) LookPath(file string) (string, error)

                    type FakeExitError

                    type FakeExitError struct {
                    	Status int

                      A simple fake ExitError type.

                      func (*FakeExitError) Error

                      func (fake *FakeExitError) Error() string

                      func (*FakeExitError) ExitStatus

                      func (fake *FakeExitError) ExitStatus() int

                      func (*FakeExitError) Exited

                      func (fake *FakeExitError) Exited() bool

                      func (*FakeExitError) String

                      func (fake *FakeExitError) String() string

                      type FakeRunAction

                      type FakeRunAction func() ([]byte, []byte, error)

                      type Interface

                      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
                      	// LookPath wraps os/exec.LookPath
                      	LookPath(file string) (string, error)

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

                        func New

                        func New() Interface

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