package exec

import "k8s.io/kubernetes/pkg/util/exec"

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

Index ¶

• Variables
• type Cmd
• func InitFakeCmd(fake *FakeCmd, cmd string, args ...string) Cmd
• type CodeExitError
• func (e CodeExitError) Error() string
• func (e CodeExitError) ExitStatus() int
• func (e CodeExitError) Exited() bool
• func (e CodeExitError) String() string
• type ExitError
• type ExitErrorWrapper
• func (eew ExitErrorWrapper) ExitStatus() int
• type FakeCmd
• func (fake *FakeCmd) CombinedOutput() ([]byte, error)
• func (fake *FakeCmd) Output() ([]byte, error)
• func (fake *FakeCmd) SetDir(dir string)
• func (fake *FakeCmd) SetStdin(in io.Reader)
• func (fake *FakeCmd) SetStdout(out io.Writer)
• type FakeCombinedOutputAction
• type FakeCommandAction
• type FakeExec
• func (fake *FakeExec) Command(cmd string, args ...string) Cmd
• func (fake *FakeExec) LookPath(file string) (string, error)
• type FakeExitError
• func (fake *FakeExitError) Error() string
• func (fake *FakeExitError) ExitStatus() int
• func (fake *FakeExitError) Exited() bool
• func (fake *FakeExitError) String() string
• type Interface
• func New() Interface

Variables ¶

var ErrExecutableNotFound = osexec.ErrNotFound

ErrExecutableNotFound is returned if the executable is not found.

Types ¶

type Cmd ¶

type Cmd interface {
	// 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)
}

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 {
	*osexec.ExitError
}

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
	Dirs                 []string
	Stdin                io.Reader
	Stdout               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) SetDir ¶

func (fake *FakeCmd) SetDir(dir string)

func (*FakeCmd) SetStdin ¶

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

func (*FakeCmd) SetStdout ¶

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

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

Source Files ¶

doc.go exec.go fake_exec.go