func (w *modelCommandWrapper) SetFlags(f *gnuflag.FlagSet) {
if !w.skipFlags {
f.StringVar(&w.envName, "m", "", "juju model to operate in")
f.StringVar(&w.envName, "model", "", "")
}
w.ModelCommand.SetFlags(f)
}
// SetFlags implements Command.SetFlags, then calls the wrapped command's SetFlags.
func (w *sysCommandWrapper) SetFlags(f *gnuflag.FlagSet) {
if w.setFlags {
f.StringVar(&w.controllerName, "c", "", "juju controller to operate in")
f.StringVar(&w.controllerName, "controller", "", "")
}
w.ControllerCommand.SetFlags(f)
}
func (w *environCommandWrapper) SetFlags(f *gnuflag.FlagSet) {
if !w.skipFlags {
f.StringVar(&w.envName, "e", "", "juju environment to operate in")
f.StringVar(&w.envName, "environment", "", "")
}
w.EnvironCommand.SetFlags(f)
}
// AddFlags injects common agent flags into f.
func (c *agentConf) AddFlags(f *gnuflag.FlagSet) {
// TODO(dimitern) 2014-02-19 bug 1282025
// We need to pass a config location here instead and
// use it to locate the conf and the infer the data-dir
// from there instead of passing it like that.
f.StringVar(&c.dataDir, "data-dir", util.DataDir, "directory for juju data")
}
func (c *DestroyEnvironmentCommand) Init(f *gnuflag.FlagSet, args []string) error {
addEnvironFlags(&c.EnvName, f)
if err := f.Parse(true, args); err != nil {
return err
}
return cmd.CheckEmpty(f.Args())
}
// SetFlags implements Command.SetFlags, then calls the wrapped command's SetFlags.
func (w *sysCommandWrapper) SetFlags(f *gnuflag.FlagSet) {
if w.setFlags {
f.StringVar(&w.systemName, "s", "", "juju system to operate in")
f.StringVar(&w.systemName, "system", "", "")
}
w.SystemCommand.SetFlags(f)
}
func (c *RelationGetCommand) SetFlags(f *gnuflag.FlagSet) {
rV := newRelationIdValue(c.ctx, &c.RelationId)
c.out.AddFlags(f, "smart", cmd.DefaultFormatters)
f.Var(rV, "r", "specify a relation by id")
f.Var(rV, "relation", "")
}
func (c *DestroyEnvironmentCommand) SetFlags(f *gnuflag.FlagSet) {
f.BoolVar(&c.assumeYes, "y", false, "Do not ask for confirmation")
f.BoolVar(&c.assumeYes, "yes", false, "")
f.BoolVar(&c.force, "force", false, "Forcefully destroy the environment, directly through the environment provider")
f.StringVar(&c.envName, "e", "", "juju environment to operate in")
f.StringVar(&c.envName, "environment", "", "juju environment to operate in")
}
func (v *VersionCommand) Init(f *gnuflag.FlagSet, args []string) error {
v.out.AddFlags(f, "smart", cmd.DefaultFormatters)
if err := f.Parse(true, args); err != nil {
return err
}
return cmd.CheckEmpty(f.Args())
}
func (w *modelCommandWrapper) SetFlags(f *gnuflag.FlagSet) {
if !w.skipFlags {
f.StringVar(&w.modelName, "m", "", "Model to operate in. Accepts [<controller name>:]<model name>")
f.StringVar(&w.modelName, "model", "", "")
}
w.ModelCommand.SetFlags(f)
}
func (c *portCommand) Init(f *gnuflag.FlagSet, args []string) error {
if err := f.Parse(true, args); err != nil {
return err
}
args = f.Args()
if args == nil {
return errors.New("no port specified")
}
parts := strings.Split(args[0], "/")
if len(parts) > 2 {
return fmt.Errorf("expected %s; got %q", portFormat, args[0])
}
port, err := strconv.Atoi(parts[0])
if err != nil {
return badPort(parts[0])
}
if port < 1 || port > 65535 {
return badPort(port)
}
protocol := "tcp"
if len(parts) == 2 {
protocol = strings.ToLower(parts[1])
if protocol != "tcp" && protocol != "udp" {
return fmt.Errorf(`protocol must be "tcp" or "udp"; got %q`, protocol)
}
}
c.Port = port
c.Protocol = protocol
return cmd.CheckEmpty(args[1:])
}
func (c *RunCommand) SetFlags(f *gnuflag.FlagSet) {
f.BoolVar(&c.noContext, "no-context", false, "do not run the command in a unit context")
f.StringVar(&c.relationId, "r", "", "run the commands for a specific relation context on a unit")
f.StringVar(&c.relationId, "relation", "", "")
f.StringVar(&c.remoteUnitName, "remote-unit", "", "run the commands for a specific remote unit in a relation context on a unit")
f.BoolVar(&c.forceRemoteUnit, "force-remote-unit", false, "run the commands for a specific relation context, bypassing the remote unit check")
}
// AddFlags adds appropriate flags to f.
func (l *Log) AddFlags(f *gnuflag.FlagSet) {
f.StringVar(&l.Path, "log-file", "", "path to write log to")
// TODO(thumper): rename verbose to --show-log
f.BoolVar(&l.Verbose, "v", false, "if set, log additional messages")
f.BoolVar(&l.Verbose, "verbose", false, "if set, log additional messages")
f.BoolVar(&l.Debug, "debug", false, "if set, log debugging messages")
f.StringVar(&l.Config, "log-config", "", "specify log levels for modules")
}
// SetFlags sets utc and format flags based on user specified options.
func (c *listMachinesCommand) SetFlags(f *gnuflag.FlagSet) {
f.BoolVar(&c.isoTime, "utc", false, "display time as UTC in RFC3339 format")
c.out.AddFlags(f, "tabular", map[string]cmd.Formatter{
"yaml": cmd.FormatYaml,
"json": cmd.FormatJson,
"tabular": status.FormatMachineTabular,
})
}
func (c *listCredentialsCommand) SetFlags(f *gnuflag.FlagSet) {
f.BoolVar(&c.showSecrets, "show-secrets", false, "show secrets for displayed credentials")
c.out.AddFlags(f, "tabular", map[string]cmd.Formatter{
"yaml": cmd.FormatYaml,
"json": cmd.FormatJson,
"tabular": formatCredentialsTabular,
})
}
// SetFlags implements Command.SetFlags.
func (c *showControllerCommand) SetFlags(f *gnuflag.FlagSet) {
c.JujuCommandBase.SetFlags(f)
f.BoolVar(&c.showPasswords, "show-passwords", false, "show passwords for displayed accounts")
c.out.AddFlags(f, "yaml", map[string]cmd.Formatter{
"yaml": cmd.FormatYaml,
"json": cmd.FormatJson,
})
}
// SetFlags adds the options that apply to all commands, particularly those
// due to logging.
func (c *SuperCommand) SetFlags(f *gnuflag.FlagSet) {
c.SetCommonFlags(f)
// Only flags set by SetCommonFlags are passed on to subcommands.
// Any flags added below only take effect when no subcommand is
// specified (e.g. juju --version).
f.BoolVar(&c.showVersion, "version", false, "Show the version of juju")
c.flags = f
}
func (c *RunCommand) SetFlags(f *gnuflag.FlagSet) {
c.out.AddFlags(f, "smart", cmd.DefaultFormatters)
f.BoolVar(&c.all, "all", false, "run the commands on all the machines")
f.DurationVar(&c.timeout, "timeout", 5*time.Minute, "how long to wait before the remote command is considered to have failed")
f.Var(cmd.NewStringsValue(nil, &c.machines), "machine", "one or more machine ids")
f.Var(cmd.NewStringsValue(nil, &c.services), "service", "one or more service names")
f.Var(cmd.NewStringsValue(nil, &c.units), "unit", "one or more unit ids")
}
// SetFlags implements cmd.Command.
func (c *ListCharmResourcesCommand) SetFlags(f *gnuflag.FlagSet) {
defaultFormat := "tabular"
c.out.AddFlags(f, defaultFormat, map[string]cmd.Formatter{
"tabular": FormatCharmTabular,
"yaml": cmd.FormatYaml,
"json": cmd.FormatJson,
})
f.StringVar(&c.channel, "channel", "stable", "the charmstore channel of the charm")
}
func (c *BootstrapCommand) SetFlags(f *gnuflag.FlagSet) {
c.AgentConf.AddFlags(f)
yamlBase64Var(f, &c.EnvConfig, "env-config", "", "initial environment configuration (yaml, base64 encoded)")
f.Var(constraints.ConstraintsValue{Target: &c.Constraints}, "constraints", "initial environment constraints (space-separated strings)")
f.Var(&c.Hardware, "hardware", "hardware characteristics (space-separated strings)")
f.StringVar(&c.InstanceId, "instance-id", "", "unique instance-id for bootstrap machine")
f.StringVar(&c.AdminUsername, "admin-user", "admin", "set the name for the juju admin user")
f.StringVar(&c.ImageMetadataDir, "image-metadata", "", "custom image metadata source dir")
}
func (c *apiInfoCommand) SetFlags(f *gnuflag.FlagSet) {
c.out.AddFlags(f, "default", map[string]cmd.Formatter{
"default": c.format,
"yaml": cmd.FormatYaml,
"json": cmd.FormatJson,
})
f.BoolVar(&c.refresh, "refresh", false, "connect to the API to ensure an up-to-date endpoint location")
f.BoolVar(&c.password, "password", false, "include the password in the output fields")
}
// SetFlags handles known option flags.
func (c *restoreCommand) SetFlags(f *gnuflag.FlagSet) {
f.Var(constraints.ConstraintsValue{Target: &c.constraints},
"constraints", "set environment constraints")
f.BoolVar(&c.bootstrap, "b", false, "bootstrap a new state machine")
f.StringVar(&c.filename, "file", "", "provide a file to be used as the backup.")
f.StringVar(&c.backupId, "id", "", "provide the name of the backup to be restored.")
f.BoolVar(&c.uploadTools, "upload-tools", false, "upload tools if bootstraping a new machine.")
}
// SetFlags implements Command.SetFlags.
func (c *listCommand) SetFlags(f *gnuflag.FlagSet) {
c.infoCommandBase.SetFlags(f)
f.BoolVar(&c.All, "all", false, "Include disabled users")
c.out.AddFlags(f, "tabular", map[string]cmd.Formatter{
"yaml": cmd.FormatYaml,
"json": cmd.FormatJson,
"tabular": c.formatTabular,
})
}
// SetFlags adds the options that apply to all commands, particularly those
// due to logging.
func (c *SuperCommand) SetFlags(f *gnuflag.FlagSet) {
if c.Log != nil {
c.Log.AddFlags(f)
}
f.BoolVar(&c.showHelp, "h", false, helpPurpose)
f.BoolVar(&c.showHelp, "help", false, "")
c.flags = f
}
// ParseArgs encapsulate the parsing of the args so this function can be
// called from the testing module too.
func ParseArgs(c Command, f *gnuflag.FlagSet, args []string) error {
// If the command is a SuperCommand, we want to parse the args with
// allowIntersperse=false (i.e. the first parameter to Parse. 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.
_, isSuperCommand := c.(*SuperCommand)
return f.Parse(!isSuperCommand, args)
}
func (c *ValidateImageMetadataCommand) SetFlags(f *gnuflag.FlagSet) {
c.out.AddFlags(f, "smart", cmd.DefaultFormatters)
f.StringVar(&c.providerType, "p", "", "the provider type eg ec2, openstack")
f.StringVar(&c.metadataDir, "d", "", "directory where metadata files are found")
f.StringVar(&c.series, "s", "", "the series for which to validate (overrides env config series)")
f.StringVar(&c.region, "r", "", "the region for which to validate (overrides env config region)")
f.StringVar(&c.endpoint, "u", "", "the cloud endpoint URL for which to validate (overrides env config endpoint)")
f.StringVar(&c.stream, "m", "", "the images stream (defaults to released)")
}
// SetFlags is defined on the cmd.Command interface.
func (c *listCommand) SetFlags(f *gnuflag.FlagSet) {
c.SpaceCommandBase.SetFlags(f)
c.out.AddFlags(f, "yaml", map[string]cmd.Formatter{
"yaml": cmd.FormatYaml,
"json": cmd.FormatJson,
})
f.BoolVar(&c.Short, "short", false, "only display spaces.")
}
// SetFlags implements cmd.Command.SetFlags.
func (c *ShowServiceCommand) SetFlags(f *gnuflag.FlagSet) {
const defaultFlag = "tabular"
c.out.AddFlags(f, defaultFlag, map[string]cmd.Formatter{
defaultFlag: FormatSvcTabular,
"yaml": cmd.FormatYaml,
"json": cmd.FormatJson,
})
f.BoolVar(&c.details, "details", false, "show detailed information about resources used by each unit.")
}
// SetFlags adds the options that apply to all commands, particularly those
// due to logging.
func (c *SuperCommand) SetFlags(f *gnuflag.FlagSet) {
c.SetCommonFlags(f)
// Only flags set by SetCommonFlags are passed on to subcommands.
// Any flags added below only take effect when no subcommand is
// specified (e.g. command --version).
if c.version != "" {
f.BoolVar(&c.showVersion, "version", false, "Show the command's version and exit")
}
c.flags = f
}
// SetFlags is defined on the cmd.Command interface.
func (c *ListCommand) SetFlags(f *gnuflag.FlagSet) {
c.SubnetCommandBase.SetFlags(f)
c.out.AddFlags(f, "yaml", map[string]cmd.Formatter{
"yaml": cmd.FormatYaml,
"json": cmd.FormatJson,
})
f.StringVar(&c.SpaceName, "space", "", "filter results by space name")
f.StringVar(&c.ZoneName, "zone", "", "filter results by zone name")
}