cli

Documentation

Index

• type AppendCommand
  • func NewAppendCommand(c *client.Client, stdout io.Writer, stderr io.Writer) *AppendCommand
  • func (cmd *AppendCommand) GetName() string
  • func (cmd *AppendCommand) IsSane() bool
  • func (cmd *AppendCommand) Parse(args []string) (success bool)
  • func (cmd *AppendCommand) Run()
• type AppendMode
• type CatCommand
  • func NewCatCommand(c *client.Client, stdout io.Writer, stderr io.Writer) *CatCommand
  • func (cmd *CatCommand) GetName() string
  • func (cmd *CatCommand) IsSane() bool
  • func (cmd *CatCommand) Parse(args []string) (success bool)
  • func (cmd *CatCommand) Run()
• type CdCommand
  • func NewCdCommand(c *client.Client, stdout io.Writer, stderr io.Writer) *CdCommand
  • func (cmd *CdCommand) GetName() string
  • func (cmd *CdCommand) IsSane() bool
  • func (cmd *CdCommand) Parse(args []string) (success bool)
  • func (cmd *CdCommand) Run()
• type Command
• type CopyCommand
  • func NewCopyCommand(c *client.Client, stdout io.Writer, stderr io.Writer) *CopyCommand
  • func (cmd *CopyCommand) GetName() string
  • func (cmd *CopyCommand) IsSane() bool
  • func (cmd *CopyCommand) Parse(args []string) (success bool)
  • func (cmd *CopyCommand) Run()
• type GrepCommand
  • func NewGrepCommand(c *client.Client, stdout io.Writer, stderr io.Writer) *GrepCommand
  • func (cmd *GrepCommand) GetName() string
  • func (cmd *GrepCommand) IsSane() bool
  • func (cmd *GrepCommand) Parse(args []string) (success bool)
  • func (cmd *GrepCommand) Run()
• type ListCommand
  • func NewListCommand(c *client.Client, stdout io.Writer, stderr io.Writer) *ListCommand
  • func (cmd *ListCommand) GetName() string
  • func (cmd *ListCommand) IsSane() bool
  • func (cmd *ListCommand) Parse(args []string) (success bool)
  • func (cmd *ListCommand) Run()
• type Match
• type MoveCommand
  • func NewMoveCommand(c *client.Client, stdout io.Writer, stderr io.Writer) *MoveCommand
  • func (cmd *MoveCommand) GetName() string
  • func (cmd *MoveCommand) IsSane() bool
  • func (cmd *MoveCommand) Parse(args []string) (success bool)
  • func (cmd *MoveCommand) Run()
• type RemoveCommand
  • func NewRemoveCommand(c *client.Client, stdout io.Writer, stderr io.Writer) *RemoveCommand
  • func (cmd *RemoveCommand) GetName() string
  • func (cmd *RemoveCommand) IsSane() bool
  • func (cmd *RemoveCommand) Parse(args []string) (success bool)
  • func (cmd *RemoveCommand) Run()

Types

type AppendCommand

type AppendCommand struct {
	Source string
	Target string
	Mode   AppendMode
	// contains filtered or unexported fields
}

AppendCommand container for all 'append' parameters

func NewAppendCommand

func NewAppendCommand(c *client.Client, stdout io.Writer, stderr io.Writer) *AppendCommand

NewAppendCommand creates a new AppendCommand parameter container

func (*AppendCommand) GetName

func (cmd *AppendCommand) GetName() string

GetName returns the AppendCommand's name identifier

func (*AppendCommand) IsSane

func (cmd *AppendCommand) IsSane() bool

IsSane returns true if command is sane

func (*AppendCommand) Parse

func (cmd *AppendCommand) Parse(args []string) (success bool)

Parse parses the arguments and returns true on success; otherwise it prints usage and returns false

func (*AppendCommand) Run

func (cmd *AppendCommand) Run()

Run executes 'append' with given AppendCommand's parameters

type AppendMode

type AppendMode string

AppendMode defines behaviour in case existing secrets are in conflict

const (
	// ModeSkip do not append secret on conflict
	ModeSkip AppendMode = "skip"
	// ModeOverwrite overwrite existing secret on conflict
	ModeOverwrite AppendMode = "overwrite"
	// ModeRename keep existing secret and create a new key on conflict
	ModeRename AppendMode = "rename"
	// ModeInvalid denotes invalid mode
	ModeInvalid AppendMode = "invalid"
)

type CatCommand

type CatCommand struct {
	Path string
	// contains filtered or unexported fields
}

CatCommand container for all 'cat' parameters

func NewCatCommand

func NewCatCommand(c *client.Client, stdout io.Writer, stderr io.Writer) *CatCommand

NewCatCommand creates a new CatCommand parameter container

func (*CatCommand) GetName

func (cmd *CatCommand) GetName() string

GetName returns the CatCommand's name identifier

func (*CatCommand) IsSane

func (cmd *CatCommand) IsSane() bool

IsSane returns true if command is sane

func (*CatCommand) Parse

func (cmd *CatCommand) Parse(args []string) (success bool)

Parse given arguments and return status

func (*CatCommand) Run

func (cmd *CatCommand) Run()

Run executes 'cat' with given CatCommand's parameters

type CdCommand

type CdCommand struct {
	Path string
	// contains filtered or unexported fields
}

CdCommand container for all 'cd' parameters

func NewCdCommand

func NewCdCommand(c *client.Client, stdout io.Writer, stderr io.Writer) *CdCommand

NewCdCommand creates a new CdCommand parameter container

func (*CdCommand) GetName

func (cmd *CdCommand) GetName() string

GetName returns the CdCommand's name identifier

func (*CdCommand) IsSane

func (cmd *CdCommand) IsSane() bool

IsSane returns true if command is sane

func (*CdCommand) Parse

func (cmd *CdCommand) Parse(args []string) (success bool)

Parse given arguments and return status

func (*CdCommand) Run

func (cmd *CdCommand) Run()

Run executes 'cd' with given CdCommand's parameters

type Command

type Command interface {
	Run()
	GetName() string
	IsSane() bool
	Parse(args []string) bool
}

Command interface to describe a command structure

type CopyCommand

type CopyCommand struct {
	Source string
	Target string
	// contains filtered or unexported fields
}

CopyCommand container for all 'cp' parameters

func NewCopyCommand

func NewCopyCommand(c *client.Client, stdout io.Writer, stderr io.Writer) *CopyCommand

NewCopyCommand creates a new CopyCommand parameter container

func (*CopyCommand) GetName

func (cmd *CopyCommand) GetName() string

GetName returns the CopyCommand's name identifier

func (*CopyCommand) IsSane

func (cmd *CopyCommand) IsSane() bool

IsSane returns true if command is sane

func (*CopyCommand) Parse

func (cmd *CopyCommand) Parse(args []string) (success bool)

Parse given arguments and return status

func (*CopyCommand) Run

func (cmd *CopyCommand) Run()

Run executes 'cp' with given CopyCommand's parameters

type GrepCommand

type GrepCommand struct {
	Path   string
	Search string
	// contains filtered or unexported fields
}

GrepCommand container for all 'grep' parameters

func NewGrepCommand

func NewGrepCommand(c *client.Client, stdout io.Writer, stderr io.Writer) *GrepCommand

NewGrepCommand creates a new GrepCommand parameter container

func (*GrepCommand) GetName

func (cmd *GrepCommand) GetName() string

GetName returns the GrepCommand's name identifier

func (*GrepCommand) IsSane

func (cmd *GrepCommand) IsSane() bool

IsSane returns true if command is sane

func (*GrepCommand) Parse

func (cmd *GrepCommand) Parse(args []string) (success bool)

Parse given arguments and return status

func (*GrepCommand) Run

func (cmd *GrepCommand) Run()

Run executes 'grep' with given RemoveCommand's parameters

type ListCommand

type ListCommand struct {
	Path string
	// contains filtered or unexported fields
}

ListCommand container for 'ls' parameters

func NewListCommand

func NewListCommand(c *client.Client, stdout io.Writer, stderr io.Writer) *ListCommand

NewListCommand creates a new ListCommand parameter container

func (*ListCommand) GetName

func (cmd *ListCommand) GetName() string

GetName returns the ListCommand's name identifier

func (*ListCommand) IsSane

func (cmd *ListCommand) IsSane() bool

IsSane returns true if command is sane

func (*ListCommand) Parse

func (cmd *ListCommand) Parse(args []string) (success bool)

Parse given arguments and return status

func (*ListCommand) Run

func (cmd *ListCommand) Run()

Run executes 'ls' with given ListCommand's parameters

type Match

type Match struct {
	// contains filtered or unexported fields
}

Match structure to keep indices of matched terms

type MoveCommand

type MoveCommand struct {
	Source string
	Target string
	// contains filtered or unexported fields
}

MoveCommand container for all 'mv' parameters

func NewMoveCommand

func NewMoveCommand(c *client.Client, stdout io.Writer, stderr io.Writer) *MoveCommand

NewMoveCommand creates a new MoveCommand parameter container

func (*MoveCommand) GetName

func (cmd *MoveCommand) GetName() string

GetName returns the MoveCommand's name identifier

func (*MoveCommand) IsSane

func (cmd *MoveCommand) IsSane() bool

IsSane returns true if command is sane

func (*MoveCommand) Parse

func (cmd *MoveCommand) Parse(args []string) (success bool)

Parse given arguments and return status

func (*MoveCommand) Run

func (cmd *MoveCommand) Run()

Run executes 'mv' with given MoveCommand's parameters

type RemoveCommand

type RemoveCommand struct {
	Path string
	// contains filtered or unexported fields
}

RemoveCommand container for all 'rm' parameters

func NewRemoveCommand

func NewRemoveCommand(c *client.Client, stdout io.Writer, stderr io.Writer) *RemoveCommand

NewRemoveCommand creates a new RemoveCommand parameter container

func (*RemoveCommand) GetName

func (cmd *RemoveCommand) GetName() string

GetName returns the RemoveCommand's name identifier

func (*RemoveCommand) IsSane

func (cmd *RemoveCommand) IsSane() bool

IsSane returns true if command is sane

func (*RemoveCommand) Parse

func (cmd *RemoveCommand) Parse(args []string) (success bool)

Parse given arguments and return status

func (*RemoveCommand) Run

func (cmd *RemoveCommand) Run()

Run executes 'rm' with given RemoveCommand's parameters