cmd

package
v0.0.0-...-65247a5 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 21, 2014 License: AGPL-3.0 Imports: 21 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	ContainerSnippet     = "(/[a-z]+/" + names.NumberSnippet + ")"
	ContainerSpecSnippet = "([a-z]+:)?"
)
View Source 
const CurrentEnvironmentFilename = "current-environment"

Variables

View Source 
var DefaultFormatters = map[string]Formatter{
	"smart": FormatSmart,
	"yaml":  FormatYaml,
	"json":  FormatJson,
}

DefaultFormatters holds the formatters that can be specified with the --format flag.

View Source 
var ErrNoPath = errors.New("path not set")
View Source 
var ErrSilent = errors.New("cmd: error out silently")

ErrSilent can be returned from Run to signal that Main should exit with code 1 without producing error output.

View Source 
var FormatJson = json.Marshal

FormatJson marshals value to a json-formatted []byte.

Functions

func CheckEmpty 

func CheckEmpty(args []string) error

CheckEmpty is a utility function that returns an error if args is not empty.

func FormatSmart 

func FormatSmart(value interface{}) ([]byte, error)

FormatSmart marshals value into a []byte according to the following rules:

  • string: untouched
  • bool: converted to `True` or `False` (to match pyjuju)
  • int or float: converted to sensible strings
  • []string: joined by `\n`s into a single string
  • anything else: delegate to FormatYaml

func FormatYaml 

func FormatYaml(value interface{}) ([]byte, error)

FormatYaml marshals value to a yaml-formatted []byte, unless value is nil.

func IsMachineOrNewContainer 

func IsMachineOrNewContainer(spec string) bool

IsMachineOrNewContainer returns whether spec is a valid machine id or new container definition.

func IsRcPassthroughError 

func IsRcPassthroughError(err error) bool

func Main 

func Main(c Command, ctx *Context, args []string) int

Main runs the given Command in the supplied Context with the given arguments, which should not include the command name. It returns a code suitable for passing to os.Exit.

func NewCommandLogWriter 

func NewCommandLogWriter(name string, out, err io.Writer) loggo.Writer

NewCommandLogWriter creates a loggo writer for registration by the callers of a command. This way the logged output can also be displayed otherwise, e.g. on the screen.

func NewRcPassthroughError 

func NewRcPassthroughError(code int) error

NewRcPassthroughError creates an error that will have the code used at the return code from the cmd.Main function rather than the default of 1 if there is an error.

func ReadCurrentEnvironment 

func ReadCurrentEnvironment() string

Read the file $JUJU_HOME/current-environment and return the value stored there. If the file doesn't exist, or there is a problem reading the file, an empty string is returned.

func WriteCurrentEnvironment 

func WriteCurrentEnvironment(envName string) error

Write the envName to the file $JUJU_HOME/current-environment file.

func ZeroOrOneArgs 

func ZeroOrOneArgs(args []string) (string, error)

ZeroOrOneArgs checks to see that there are zero or one args, and returns the value of the arg if provided, or the empty string if not.

Types

type Command 

type Command interface {
	// IsSuperCommand returns true if the command is a super command.
	IsSuperCommand() bool

	// Info returns information about the Command.
	Info() *Info

	// SetFlags adds command specific flags to the flag set.
	SetFlags(f *gnuflag.FlagSet)

	// Init initializes the Command before running.
	Init(args []string) error

	// Run will execute the Command as directed by the options and positional
	// arguments passed to Init.
	Run(ctx *Context) error

	// AllowInterspersedFlags returns whether the command allows flag
	// arguments to be interspersed with non-flag arguments.
	AllowInterspersedFlags() bool
}

Command is implemented by types that interpret command-line arguments.

type CommandBase 

type CommandBase struct{}

CommandBase provides the default implementation for SetFlags, Init, and Help.

func (*CommandBase) AllowInterspersedFlags 

func (c *CommandBase) AllowInterspersedFlags() bool

AllowInterspersedFlags returns true by default. Some subcommands may want to override this.

func (*CommandBase) Init 

func (c *CommandBase) Init(args []string) error

Init in the simplest case makes sure there are no args.

func (*CommandBase) IsSuperCommand 

func (c *CommandBase) IsSuperCommand() bool

IsSuperCommand implements Command.IsSuperCommand

func (*CommandBase) SetFlags 

func (c *CommandBase) SetFlags(f *gnuflag.FlagSet)

SetFlags does nothing in the simplest case.

type Context 

type Context struct {
	Dir    string
	Stdin  io.Reader
	Stdout io.Writer
	Stderr io.Writer
}

Context represents the run context of a Command. Command implementations should interpret file names relative to Dir (see AbsPath below), and print output and errors to Stdout and Stderr respectively.

func DefaultContext 

func DefaultContext() *Context

DefaultContext returns a Context suitable for use in non-hosted situations.

func (*Context) AbsPath 

func (ctx *Context) AbsPath(path string) string

AbsPath returns an absolute representation of path, with relative paths interpreted as relative to ctx.Dir.

func (*Context) GetStderr 

func (ctx *Context) GetStderr() io.Writer

GetStderr satisfies environs.BootstrapContext

func (*Context) GetStdin 

func (ctx *Context) GetStdin() io.Reader

GetStdin satisfies environs.BootstrapContext

func (*Context) GetStdout 

func (ctx *Context) GetStdout() io.Writer

GetStdout satisfies environs.BootstrapContext

func (*Context) InterruptNotify 

func (ctx *Context) InterruptNotify(c chan<- os.Signal)

InterruptNotify satisfies environs.BootstrapContext

func (*Context) StopInterruptNotify 

func (ctx *Context) StopInterruptNotify(c chan<- os.Signal)

StopInterruptNotify satisfies environs.BootstrapContext

type EnvCommandBase 

type EnvCommandBase struct {
	CommandBase
	EnvName string
}

The purpose of EnvCommandBase is to provide a default member and flag setting for commands that deal across different environments.

func (*EnvCommandBase) EnvironName 

func (c *EnvCommandBase) EnvironName() string

EnvironName returns the name of the environment for this command

func (*EnvCommandBase) SetFlags 

func (c *EnvCommandBase) SetFlags(f *gnuflag.FlagSet)

type FileVar 

type FileVar struct {
	Path string
}

FileVar represents a path to a file.

func (*FileVar) Read 

func (f *FileVar) Read(ctx *Context) ([]byte, error)

Read returns the contents of the file.

func (*FileVar) Set 

func (f *FileVar) Set(v string) error

Set stores the chosen path name in f.Path.

func (*FileVar) String 

func (f *FileVar) String() string

String returns the path to the file.

type Formatter 

type Formatter func(value interface{}) ([]byte, error)

Formatter converts an arbitrary object into a []byte.

type Info 

type Info struct {
	// Name is the Command's name.
	Name string

	// Args describes the command's expected positional arguments.
	Args string

	// Purpose is a short explanation of the Command's purpose.
	Purpose string

	// Doc is the long documentation for the Command.
	Doc string

	// Aliases are other names for the Command.
	Aliases []string
}

Info holds some of the usage documentation of a Command.

func (*Info) Help 

func (i *Info) Help(f *gnuflag.FlagSet) []byte

Help renders i's content, along with documentation for any flags defined in f. It calls f.SetOutput(ioutil.Discard).

type Log 

type Log struct {
	Path    string
	Verbose bool
	Debug   bool
	ShowLog bool
	Config  string
	Factory WriterFactory
}

Log supplies the necessary functionality for Commands that wish to set up logging.

func (*Log) AddFlags 

func (l *Log) AddFlags(f *gnuflag.FlagSet)

AddFlags adds appropriate flags to f.

func (*Log) GetLogWriter 

func (l *Log) GetLogWriter(target io.Writer) loggo.Writer

GetLogWriter returns a logging writer for the specified target.

func (*Log) Start 

func (l *Log) Start(ctx *Context) error

Start starts logging using the given Context.

type MissingCallback 

type MissingCallback func(ctx *Context, subcommand string, args []string) error

MissingCallback defines a function that will be used by the SuperCommand if the requested subcommand isn't found.

type Output 

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

Output is responsible for interpreting output-related command line flags and writing a value to a file or to stdout as directed.

func (*Output) AddFlags 

func (c *Output) AddFlags(f *gnuflag.FlagSet, defaultFormatter string, formatters map[string]Formatter)

AddFlags injects the --format and --output command line flags into f.

func (*Output) Name 

func (c *Output) Name() string

func (*Output) Write 

func (c *Output) Write(ctx *Context, value interface{}) (err error)

Write formats and outputs the value as directed by the --format and --output command line flags.

type StringsValue 

type StringsValue []string

StringsValue implements gnuflag.Value for a comma separated list of strings. This allows flags to be created where the target is []string, and the caller is after comma separated values.

func NewStringsValue 

func NewStringsValue(defaultValue []string, target *[]string) *StringsValue

NewStringsValue is used to create the type passed into the gnuflag.FlagSet Var function. f.Var(cmd.NewStringsValue(defaultValue, &someMember), "name", "help")

func (*StringsValue) Set 

func (v *StringsValue) Set(s string) error

Implements gnuflag.Value Set.

func (*StringsValue) String 

func (v *StringsValue) String() string

Implements gnuflag.Value String.

type SuperCommand 

type SuperCommand struct {
	CommandBase
	Name    string
	Purpose string
	Doc     string
	Log     *Log
	// contains filtered or unexported fields
}

SuperCommand is a Command that selects a subcommand and assumes its properties; any command line arguments that were not used in selecting the subcommand are passed down to it, and to Run a SuperCommand is to run its selected subcommand.

func NewSuperCommand 

func NewSuperCommand(params SuperCommandParams) *SuperCommand

NewSuperCommand creates and initializes a new `SuperCommand`, and returns the fully initialized structure.

func (*SuperCommand) AddHelpTopic 

func (c *SuperCommand) AddHelpTopic(name, short, long string, aliases ...string)

AddHelpTopic adds a new help topic with the description being the short param, and the full text being the long param. The description is shown in 'help topics', and the full text is shown when the command 'help <name>' is called.

func (*SuperCommand) AddHelpTopicCallback 

func (c *SuperCommand) AddHelpTopicCallback(name, short string, longCallback func() string)

AddHelpTopicCallback adds a new help topic with the description being the short param, and the full text being defined by the callback function.

func (*SuperCommand) AllowInterspersedFlags 

func (c *SuperCommand) AllowInterspersedFlags() bool

For a SuperCommand, we want to parse the args with allowIntersperse=false. This will mean that the args may contain other options that haven't been defined yet, and that only options that relate to the SuperCommand itself can come prior to the subcommand name.

func (*SuperCommand) Info 

func (c *SuperCommand) Info() *Info

Info returns a description of the currently selected subcommand, or of the SuperCommand itself if no subcommand has been specified.

func (*SuperCommand) Init 

func (c *SuperCommand) Init(args []string) error

Init initializes the command for running.

func (*SuperCommand) IsSuperCommand 

func (c *SuperCommand) IsSuperCommand() bool

IsSuperCommand implements Command.IsSuperCommand

func (*SuperCommand) Register 

func (c *SuperCommand) Register(subcmd Command)

Register makes a subcommand available for use on the command line. The command will be available via its own name, and via any supplied aliases.

func (*SuperCommand) Run 

func (c *SuperCommand) Run(ctx *Context) error

Run executes the subcommand that was selected in Init.

func (*SuperCommand) SetCommonFlags 

func (c *SuperCommand) SetCommonFlags(f *gnuflag.FlagSet)

SetCommonFlags creates a new "commonflags" flagset, whose flags are shared with the argument f; this enables us to add non-global flags to f, which do not carry into subcommands.

func (*SuperCommand) SetFlags 

func (c *SuperCommand) SetFlags(f *gnuflag.FlagSet)

SetFlags adds the options that apply to all commands, particularly those due to logging.

type SuperCommandParams 

type SuperCommandParams struct {
	UsagePrefix     string
	Name            string
	Purpose         string
	Doc             string
	Log             *Log
	MissingCallback MissingCallback
}

SuperCommandParams provides a way to have default parameter to the `NewSuperCommand` call.

type UnrecognizedCommand 

type UnrecognizedCommand struct {
	Name string
}

func (*UnrecognizedCommand) Error 

func (e *UnrecognizedCommand) Error() string

type VersionCommand 

type VersionCommand struct {
	CommandBase
	// contains filtered or unexported fields
}

VersionCommand is a cmd.Command that prints the current version.

func (*VersionCommand) Info 

func (v *VersionCommand) Info() *Info

func (*VersionCommand) Run 

func (v *VersionCommand) Run(ctxt *Context) error

func (*VersionCommand) SetFlags 

func (v *VersionCommand) SetFlags(f *gnuflag.FlagSet)

type WriterFactory 

type WriterFactory interface {
	NewWriter(target io.Writer) loggo.Writer
}

WriterFactory defines the single method to create a new logging writer for a specified output target.

Source Files

View all Source files

Directories

Path Synopsis
plugins
juju-metadata
juju-restore
local
local/juju-local

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.