func (w *modelCommandWrapper) SetFlags(f *gnuflag.FlagSet) {
if !w.skipModelFlags {
f.StringVar(&w.modelName, "m", "", "Model to operate in. Accepts [<controller name>:]<model name>")
f.StringVar(&w.modelName, "model", "", "")
}
w.ModelCommand.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")
}
// SetFlags implements Command.SetFlags, then calls the wrapped command's SetFlags.
func (w *sysCommandWrapper) SetFlags(f *gnuflag.FlagSet) {
if w.setControllerFlags {
f.StringVar(&w.controllerName, "c", "", "Controller to operate in")
f.StringVar(&w.controllerName, "controller", "", "")
}
w.ControllerCommand.SetFlags(f)
}
func (c *addCommand) SetFlags(f *gnuflag.FlagSet) {
c.ModelCommandBase.SetFlags(f)
f.StringVar(&c.Series, "series", "", "The charm series")
f.IntVar(&c.NumMachines, "n", 1, "The number of machines to add")
f.StringVar(&c.ConstraintsStr, "constraints", "", "Additional machine constraints")
f.Var(disksFlag{&c.Disks}, "disks", "Constraints for disks to attach to the machine")
}
func (c *debugLogCommand) SetFlags(f *gnuflag.FlagSet) {
c.ModelCommandBase.SetFlags(f)
f.Var(cmd.NewAppendStringsValue(&c.params.IncludeEntity), "i", "Only show log messages for these entities")
f.Var(cmd.NewAppendStringsValue(&c.params.IncludeEntity), "include", "Only show log messages for these entities")
f.Var(cmd.NewAppendStringsValue(&c.params.ExcludeEntity), "x", "Do not show log messages for these entities")
f.Var(cmd.NewAppendStringsValue(&c.params.ExcludeEntity), "exclude", "Do not show log messages for these entities")
f.Var(cmd.NewAppendStringsValue(&c.params.IncludeModule), "include-module", "Only show log messages for these logging modules")
f.Var(cmd.NewAppendStringsValue(&c.params.ExcludeModule), "exclude-module", "Do not show log messages for these logging modules")
f.StringVar(&c.level, "l", "", "Log level to show, one of [TRACE, DEBUG, INFO, WARNING, ERROR]")
f.StringVar(&c.level, "level", "", "")
f.UintVar(&c.params.Backlog, "n", defaultLineCount, "Show this many of the most recent (possibly filtered) lines, and continue to append")
f.UintVar(&c.params.Backlog, "lines", defaultLineCount, "")
f.UintVar(&c.params.Limit, "limit", 0, "Exit once this many of the most recent (possibly filtered) lines are shown")
f.BoolVar(&c.params.Replay, "replay", false, "Show the entire (possibly filtered) log and continue to append")
f.BoolVar(&c.notail, "no-tail", false, "Stop after returning existing log messages")
f.BoolVar(&c.tail, "tail", false, "Wait for new logs")
f.BoolVar(&c.color, "color", false, "Force use of ANSI color codes")
f.BoolVar(&c.utc, "utc", false, "Show times in UTC")
f.BoolVar(&c.location, "location", false, "Show filename and line numbers")
f.BoolVar(&c.date, "date", false, "Show dates as well as times")
f.BoolVar(&c.ms, "ms", false, "Show times to millisecond precision")
}
// SetFlags is defined on the cmd.Command interface.
func (c *listCommand) SetFlags(f *gnuflag.FlagSet) {
c.SubnetCommandBase.SetFlags(f)
c.Out.AddFlags(f, "yaml", output.DefaultFormatters)
f.StringVar(&c.SpaceName, "space", "", "Filter results by space name")
f.StringVar(&c.ZoneName, "zone", "", "Filter results by zone name")
}
func (c *toolsMetadataCommand) SetFlags(f *gnuflag.FlagSet) {
f.StringVar(&c.metadataDir, "d", "", "local directory in which to store metadata")
// If no stream is specified, we'll generate metadata for the legacy tools location.
f.StringVar(&c.stream, "stream", "", "simplestreams stream for which to generate the metadata")
f.BoolVar(&c.clean, "clean", false, "remove any existing metadata for the specified stream before generating new metadata")
f.BoolVar(&c.public, "public", false, "tools are for a public cloud, so generate mirrors information")
}
func (c *statusHistoryCommand) SetFlags(f *gnuflag.FlagSet) {
c.ModelCommandBase.SetFlags(f)
f.StringVar(&c.outputContent, "type", "unit", "Type of statuses to be displayed [agent|workload|combined|machine|machineInstance|container|containerinstance]")
f.IntVar(&c.backlogSize, "n", 0, "Returns the last N logs (cannot be combined with --days or --date)")
f.IntVar(&c.backlogSizeDays, "days", 0, "Returns the logs for the past <days> days (cannot be combined with -n or --date)")
f.StringVar(&c.backlogDate, "date", "", "Returns logs for any date after the passed one, the expected date format is YYYY-MM-DD (cannot be combined with -n or --days)")
f.BoolVar(&c.isoTime, "utc", false, "Display time as UTC in RFC3339 format")
}
func (c *upgradeJujuCommand) SetFlags(f *gnuflag.FlagSet) {
c.ModelCommandBase.SetFlags(f)
f.StringVar(&c.vers, "agent-version", "", "Upgrade to specific version")
f.BoolVar(&c.BuildAgent, "build-agent", false, "Build a local version of the agent binary; for development use only")
f.BoolVar(&c.DryRun, "dry-run", false, "Don't change anything, just report what would be changed")
f.BoolVar(&c.ResetPrevious, "reset-previous-upgrade", false, "Clear the previous (incomplete) upgrade status (use with care)")
f.BoolVar(&c.AssumeYes, "y", false, "Answer 'yes' to confirmation prompts")
f.BoolVar(&c.AssumeYes, "yes", false, "")
}
func (c *validateImageMetadataCommand) SetFlags(f *gnuflag.FlagSet) {
c.out.AddFlags(f, "yaml", output.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, "stream", "", "the images stream (defaults to released)")
}
func (c *RelationSetCommand) SetFlags(f *gnuflag.FlagSet) {
f.Var(c.relationIdProxy, "r", "specify a relation by id")
f.Var(c.relationIdProxy, "relation", "")
c.settingsFile.SetStdin()
f.Var(&c.settingsFile, "file", "file containing key-value pairs")
f.StringVar(&c.formatFlag, "format", "", "deprecated format flag")
}
// AddFlags adds appropriate flags to f.
func (l *Log) AddFlags(f *gnuflag.FlagSet) {
f.StringVar(&l.Path, "log-file", "", "path to write log to")
f.BoolVar(&l.Verbose, "v", false, "show more verbose output")
f.BoolVar(&l.Verbose, "verbose", false, "show more verbose output")
f.BoolVar(&l.Quiet, "q", false, "show no informational output")
f.BoolVar(&l.Quiet, "quiet", false, "show no informational output")
f.BoolVar(&l.Debug, "debug", false, "equivalent to --show-log --log-config=<root>=DEBUG")
f.StringVar(&l.Config, "logging-config", l.DefaultConfig, "specify log levels for modules")
f.BoolVar(&l.ShowLog, "show-log", false, "if set, write the log file to stderr")
}
func (c *syncToolsCommand) SetFlags(f *gnuflag.FlagSet) {
c.ModelCommandBase.SetFlags(f)
f.BoolVar(&c.allVersions, "all", false, "Copy all versions, not just the latest")
f.StringVar(&c.versionStr, "version", "", "Copy a specific major[.minor] version")
f.BoolVar(&c.dryRun, "dry-run", false, "Don't copy, just print what would be copied")
f.BoolVar(&c.dev, "dev", false, "Consider development versions as well as released ones\n DEPRECATED: use --stream instead")
f.BoolVar(&c.public, "public", false, "Tools are for a public cloud, so generate mirrors information")
f.StringVar(&c.source, "source", "", "Local source directory")
f.StringVar(&c.stream, "stream", "", "Simplestreams stream for which to sync metadata")
f.StringVar(&c.localDir, "local-dir", "", "Local destination directory")
f.StringVar(&c.destination, "destination", "", "Local destination directory\n DEPRECATED: use --local-dir instead")
}
func (c *enableHACommand) SetFlags(f *gnuflag.FlagSet) {
c.ModelCommandBase.SetFlags(f)
f.IntVar(&c.NumControllers, "n", 0, "Number of controllers to make available")
f.StringVar(&c.PlacementSpec, "to", "", "The machine(s) to become controllers, bypasses constraints")
f.StringVar(&c.ConstraintsStr, "constraints", "", "Additional machine constraints")
c.out.AddFlags(f, "simple", map[string]cmd.Formatter{
"yaml": cmd.FormatYaml,
"json": cmd.FormatJson,
"simple": formatSimple,
})
}
// SetFlags implements Command.SetFlags.
func (c *modelsCommand) SetFlags(f *gnuflag.FlagSet) {
c.ControllerCommandBase.SetFlags(f)
f.StringVar(&c.user, "user", "", "The user to list models for (administrative users only)")
f.BoolVar(&c.all, "all", false, "Lists all models, regardless of user accessibility (administrative users only)")
f.BoolVar(&c.listUUID, "uuid", false, "Display UUID for models")
f.BoolVar(&c.exactTime, "exact-time", false, "Use full timestamps")
c.out.AddFlags(f, "tabular", map[string]cmd.Formatter{
"yaml": cmd.FormatYaml,
"json": cmd.FormatJson,
"tabular": c.formatTabular,
})
}
// SetFlags adds the flags for this command to the passed gnuflag.FlagSet.
func (u *UpgradeMongoCommand) SetFlags(f *gnuflag.FlagSet) {
f.StringVar(&u.machineTag, "machinetag", "machine-0", "unique tag identifier for machine to be upgraded")
f.StringVar(&u.series, "series", "", "series for the machine")
f.StringVar(&u.configFilePath, "configfile", "", "path to the config file")
f.StringVar(&u.members, "members", "", "a comma separated list of replicaset member ips")
f.BoolVar(&u.rollback, "rollback", false, "rollback a previous attempt at upgrading that was cut in the process")
f.BoolVar(&u.slave, "slave", false, "this is a slave machine in a replicaset")
}
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")
}
// SetFlags implements Command.SetFlags.
func (c *listCommand) SetFlags(f *gnuflag.FlagSet) {
c.CachedImagesCommandBase.SetFlags(f)
f.StringVar(&c.Kind, "kind", "", "The image kind to list eg lxd")
f.StringVar(&c.Series, "series", "", "The series of the image to list eg xenial")
f.StringVar(&c.Arch, "arch", "", "The architecture of the image to list eg amd64")
c.out.AddFlags(f, "yaml", output.DefaultFormatters)
}
// SetFlags handles known option flags.
func (c *restoreCommand) SetFlags(f *gnuflag.FlagSet) {
c.CommandBase.SetFlags(f)
f.StringVar(&c.constraintsStr, "constraints", "", "set model 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.buildAgent, "build-agent", false, "Build binary agent if bootstraping a new machine")
}
func (c *upgradeCharmCommand) SetFlags(f *gnuflag.FlagSet) {
c.ModelCommandBase.SetFlags(f)
f.BoolVar(&c.ForceUnits, "force-units", false, "Upgrade all units immediately, even if in error state")
f.StringVar((*string)(&c.Channel), "channel", "", "Channel to use when getting the charm or bundle from the charm store")
f.BoolVar(&c.ForceSeries, "force-series", false, "Upgrade even if series of deployed applications are not supported by the new charm")
f.StringVar(&c.SwitchURL, "switch", "", "Crossgrade to a different charm")
f.StringVar(&c.CharmPath, "path", "", "Upgrade to a charm located at path")
f.IntVar(&c.Revision, "revision", -1, "Explicit revision of current charm")
f.Var(stringMap{&c.Resources}, "resource", "Resource to be uploaded to the controller")
}
// SetFlags implements Command.SetFlags.
func (c *listImagesCommand) SetFlags(f *gnuflag.FlagSet) {
c.cloudImageMetadataCommandBase.SetFlags(f)
f.StringVar(&c.Stream, "stream", "", "image metadata stream")
f.StringVar(&c.Region, "region", "", "image metadata cloud region")
f.Var(cmd.NewAppendStringsValue(&c.Series), "series", "only show cloud image metadata for these series")
f.Var(cmd.NewAppendStringsValue(&c.Arches), "arch", "only show cloud image metadata for these architectures")
f.StringVar(&c.VirtType, "virt-type", "", "image metadata virtualisation type")
f.StringVar(&c.RootStorageType, "storage-type", "", "image metadata root storage type")
c.out.AddFlags(f, "tabular", map[string]cmd.Formatter{
"yaml": cmd.FormatYaml,
"json": cmd.FormatJson,
"tabular": formatMetadataListTabular,
})
}
func (c *DeployCommand) SetFlags(f *gnuflag.FlagSet) {
// Keep above charmOnlyFlags and bundleOnlyFlags lists updated when adding
// new flags.
c.UnitCommandBase.SetFlags(f)
c.ModelCommandBase.SetFlags(f)
f.IntVar(&c.NumUnits, "n", 1, "Number of application units to deploy for principal charms")
f.StringVar((*string)(&c.Channel), "channel", "", "Channel to use when getting the charm or bundle from the charm store")
f.Var(&c.Config, "config", "Path to yaml-formatted application config")
f.StringVar(&c.ConstraintsStr, "constraints", "", "Set application constraints")
f.StringVar(&c.Series, "series", "", "The series on which to deploy")
f.BoolVar(&c.Force, "force", false, "Allow a charm to be deployed to a machine running an unsupported series")
f.Var(storageFlag{&c.Storage, &c.BundleStorage}, "storage", "Charm storage constraints")
f.Var(stringMap{&c.Resources}, "resource", "Resource to be uploaded to the controller")
f.StringVar(&c.BindToSpaces, "bind", "", "Configure application endpoint bindings to spaces")
for _, step := range c.Steps {
step.SetFlags(f)
}
c.flagSet = f
}
func (c *listToolsCommand) SetFlags(f *gnuflag.FlagSet) {
c.out.AddFlags(f, "smart", cmd.DefaultFormatters)
f.IntVar(&c.versionMajor, "major", jujuversion.Current.Major, "filter tools by major version")
f.StringVar(&c.series, "series", "", "filter tools by series")
f.StringVar(&c.arch, "arch", "", "filter tools by architecture")
}
// SetFlags implements Command.SetFlags.
func (c *SetMeterStatusCommand) SetFlags(f *gnuflag.FlagSet) {
c.ModelCommandBase.SetFlags(f)
f.StringVar(&c.StatusInfo, "info", "", "Set the meter status info to this string")
}
func (c *renameCommand) SetFlags(f *gnuflag.FlagSet) {
c.SpaceCommandBase.SetFlags(f)
f.StringVar(&c.NewName, "rename", "", "the new name for the network space")
}
func (c *signMetadataCommand) SetFlags(f *gnuflag.FlagSet) {
c.CommandBase.SetFlags(f)
f.StringVar(&c.dir, "d", "", "directory in which to look for metadata")
f.StringVar(&c.keyFile, "k", "", "file containing the amored private signing key")
f.StringVar(&c.passphrase, "p", "", "passphrase used to decrypt the private key")
}
func (c *JujuLogCommand) SetFlags(f *gnuflag.FlagSet) {
f.BoolVar(&c.Debug, "debug", false, "log at debug level")
f.StringVar(&c.Level, "l", "INFO", "Send log message at the given level")
f.StringVar(&c.Level, "log-level", "INFO", "")
f.StringVar(&c.formatFlag, "format", "", "deprecated format flag")
}
func (c *RpcCommand) SetFlags(f *gnuflag.FlagSet) {
f.StringVar(&c.Value, "value", "", "doc")
f.BoolVar(&c.Slow, "slow", false, "doc")
f.BoolVar(&c.Echo, "echo", false, "doc")
}
// SetFlags implements Command.SetFlags.
func (c *updateCredentialCommand) SetFlags(f *gnuflag.FlagSet) {
c.ControllerCommandBase.SetFlags(f)
f.StringVar(&c.credential, "credential", "", "Name of credential to update")
f.StringVar(&c.cloud, "cloud", "", "Cloud for which to update the credential")
}
// SetFlags implements Command.SetFlags.
func (c *createCommand) SetFlags(f *gnuflag.FlagSet) {
c.CommandBase.SetFlags(f)
f.BoolVar(&c.NoDownload, "no-download", false, "Do not download the archive")
f.StringVar(&c.Filename, "filename", notset, "Download to this file")
}