func (c *RelationGetCommand) Init(f *gnuflag.FlagSet, args []string) error {
// TODO FWER implement --format shell lp:1033511
c.out.AddFlags(f, "smart", cmd.DefaultFormatters)
f.Var(newRelationIdValue(c.ctx, &c.RelationId), "r", "specify a relation by id")
if err := f.Parse(true, args); err != nil {
return err
}
if c.RelationId == -1 {
return fmt.Errorf("no relation id specified")
}
args = f.Args()
c.Key = ""
if len(args) > 0 {
if c.Key = args[0]; c.Key == "-" {
c.Key = ""
}
args = args[1:]
}
if name, found := c.ctx.RemoteUnitName(); found {
c.UnitName = name
}
if len(args) > 0 {
c.UnitName = args[0]
args = args[1:]
}
if c.UnitName == "" {
return fmt.Errorf("no unit id specified")
}
return cmd.CheckEmpty(args)
}
func (c *RemoteCommand) Init(f *gnuflag.FlagSet, args []string) error {
f.StringVar(&c.msg, "error", "", "if set, fail")
if err := f.Parse(true, args); err != nil {
return err
}
return cmd.CheckEmpty(f.Args())
}
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 (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 (m *Manager) handleFlags(command Command, name string, args []string) (Command, []string, error) {
var flagset *gnuflag.FlagSet
if flagged, ok := command.(FlaggedCommand); ok {
flagset = flagged.Flags()
} else {
flagset = gnuflag.NewFlagSet(name, gnuflag.ExitOnError)
}
var helpRequested bool
flagset.SetOutput(m.stderr)
if flagset.Lookup("help") == nil {
flagset.BoolVar(&helpRequested, "help", false, "Display help and exit")
}
if flagset.Lookup("h") == nil {
flagset.BoolVar(&helpRequested, "h", false, "Display help and exit")
}
err := flagset.Parse(true, args)
if err != nil {
return nil, nil, err
}
if helpRequested {
command = m.Commands["help"]
args = []string{name}
} else {
args = flagset.Args()
}
return command, args, nil
}
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())
}
func (c *RpcCommand) Init(f *gnuflag.FlagSet, args []string) error {
f.StringVar(&c.Value, "value", "", "doc")
f.BoolVar(&c.Slow, "slow", false, "doc")
if err := f.Parse(true, args); err != nil {
return err
}
return cmd.CheckEmpty(f.Args())
}
func (c *BootstrapCommand) Init(f *gnuflag.FlagSet, args []string) error {
addEnvironFlags(&c.EnvName, f)
f.BoolVar(&c.UploadTools, "upload-tools", false, "upload local version of tools before bootstrapping")
if err := f.Parse(true, args); err != nil {
return err
}
return cmd.CheckEmpty(f.Args())
}
func (c *TestCommand) Init(f *gnuflag.FlagSet, args []string) error {
if !c.Minimal {
f.StringVar(&c.Option, "option", "", "option-doc")
}
if err := f.Parse(true, args); err != nil {
return err
}
return cmd.CheckEmpty(f.Args())
}
// Init initializes the command for running.
func (a *MachineAgent) Init(f *gnuflag.FlagSet, args []string) error {
a.Conf.addFlags(f)
f.StringVar(&a.MachineId, "machine-id", "", "id of the machine to run")
if err := f.Parse(true, args); err != nil {
return err
}
if !state.IsMachineId(a.MachineId) {
return fmt.Errorf("--machine-id option must be set, and expects a non-negative integer")
}
return a.Conf.checkArgs(f.Args())
}
func (c *StatusCommand) Init(f *gnuflag.FlagSet, args []string) error {
addEnvironFlags(&c.EnvName, f)
c.out.AddFlags(f, "yaml", map[string]cmd.Formatter{
"yaml": cmd.FormatYaml,
"json": cmd.FormatJson,
})
if err := f.Parse(true, args); err != nil {
return err
}
return cmd.CheckEmpty(f.Args())
}
func (c *ConfigGetCommand) Init(f *gnuflag.FlagSet, args []string) error {
c.out.AddFlags(f, "smart", cmd.DefaultFormatters)
if err := f.Parse(true, args); err != nil {
return err
}
args = f.Args()
if args == nil {
return nil
}
c.Key = args[0]
return cmd.CheckEmpty(args[1:])
}
func (c *DestroyRelationCommand) Init(f *gnuflag.FlagSet, args []string) error {
addEnvironFlags(&c.EnvName, f)
if err := f.Parse(true, args); err != nil {
return err
}
args = f.Args()
if len(args) != 2 {
return fmt.Errorf("a relation must involve two services")
}
c.Endpoints = args
return nil
}
func (c *UnexposeCommand) Init(f *gnuflag.FlagSet, args []string) error {
addEnvironFlags(&c.EnvName, f)
if err := f.Parse(true, args); err != nil {
return err
}
args = f.Args()
if len(args) == 0 {
return errors.New("no service name specified")
}
c.ServiceName = args[0]
return cmd.CheckEmpty(args[1:])
}
func (c *JujuLogCommand) Init(f *gnuflag.FlagSet, args []string) error {
f.BoolVar(&c.Debug, "debug", false, "log at debug level")
f.StringVar(&c.Level, "l", "INFO", "Send log message at the given level")
if err := f.Parse(true, args); err != nil {
return err
}
args = f.Args()
if args == nil {
return errors.New("no message specified")
}
c.Message = strings.Join(args, " ")
return nil
}
func (c *SCPCommand) Init(f *gnuflag.FlagSet, args []string) error {
addEnvironFlags(&c.EnvName, f)
if err := f.Parse(true, args); err != nil {
return err
}
switch len(f.Args()) {
case 0, 1:
return errors.New("at least two arguments required")
default:
c.Args = f.Args()
}
return nil
}
// Init initializes the command for running.
func (a *UnitAgent) Init(f *gnuflag.FlagSet, args []string) error {
a.Conf.addFlags(f)
f.StringVar(&a.UnitName, "unit-name", "", "name of the unit to run")
if err := f.Parse(true, args); err != nil {
return err
}
if a.UnitName == "" {
return requiredError("unit-name")
}
if !state.IsUnitName(a.UnitName) {
return fmt.Errorf(`--unit-name option expects "<service>/<n>" argument`)
}
return a.Conf.checkArgs(f.Args())
}
// Init initializes the command for running.
func (c *BootstrapCommand) Init(f *gnuflag.FlagSet, args []string) error {
c.Conf.addFlags(f)
f.StringVar(&c.InstanceId, "instance-id", "", "instance id of this machine")
yamlBase64Var(f, &c.EnvConfig, "env-config", "", "initial environment configuration (yaml, base64 encoded)")
if err := f.Parse(true, args); err != nil {
return err
}
if c.InstanceId == "" {
return requiredError("instance-id")
}
if len(c.EnvConfig) == 0 {
return requiredError("env-config")
}
return c.Conf.checkArgs(f.Args())
}
func (c *UnitGetCommand) Init(f *gnuflag.FlagSet, args []string) error {
c.out.AddFlags(f, "smart", cmd.DefaultFormatters)
if err := f.Parse(true, args); err != nil {
return err
}
args = f.Args()
if args == nil {
return errors.New("no setting specified")
}
if args[0] != "private-address" && args[0] != "public-address" {
return fmt.Errorf("unknown setting %q", args[0])
}
c.Key = args[0]
return cmd.CheckEmpty(args[1:])
}
func (c *SetCommand) Init(f *gnuflag.FlagSet, args []string) error {
addEnvironFlags(&c.EnvName, f)
f.Var(&c.Config, "config", "path to yaml-formatted service config")
if err := f.Parse(true, args); err != nil {
return err
}
args = f.Args()
if len(args) == 0 || len(strings.Split(args[0], "=")) > 1 {
return errors.New("no service name specified")
}
if len(c.Config.Path) > 0 && len(args) > 1 {
return errors.New("cannot specify --config when using key=value arguments")
}
c.ServiceName, c.Options = args[0], args[1:]
return nil
}
func (c *DestroyUnitCommand) Init(f *gnuflag.FlagSet, args []string) error {
addEnvironFlags(&c.EnvName, f)
if err := f.Parse(true, args); err != nil {
return err
}
c.UnitNames = f.Args()
if len(c.UnitNames) == 0 {
return errors.New("no units specified")
}
for _, name := range c.UnitNames {
if !state.IsUnitName(name) {
return fmt.Errorf("invalid unit name: %q", name)
}
}
return nil
}
// Init initializes the command for running.
func (c *SuperCommand) Init(f *gnuflag.FlagSet, args []string) error {
if c.Log != nil {
c.Log.AddFlags(f)
}
if err := f.Parse(false, args); err != nil {
return err
}
subargs := f.Args()
if len(subargs) == 0 {
return fmt.Errorf("no command specified")
}
found := false
if c.subcmd, found = c.subcmds[subargs[0]]; !found {
return fmt.Errorf("unrecognized command: %s %s", c.Info().Name, subargs[0])
}
return c.subcmd.Init(f, subargs[1:])
}
func (c *GetCommand) Init(f *gnuflag.FlagSet, args []string) error {
addEnvironFlags(&c.EnvName, f)
// TODO(dfc) add json formatting ?
c.out.AddFlags(f, "yaml", map[string]cmd.Formatter{
"yaml": cmd.FormatYaml,
})
// TODO(dfc) add --schema-only
if err := f.Parse(true, args); err != nil {
return err
}
args = f.Args()
if len(args) == 0 {
return errors.New("no service name specified")
}
c.ServiceName = args[0]
return cmd.CheckEmpty(args[1:])
}
func (c *RelationIdsCommand) Init(f *gnuflag.FlagSet, args []string) error {
c.out.AddFlags(f, "smart", cmd.DefaultFormatters)
if err := f.Parse(true, args); err != nil {
return err
}
args = f.Args()
if r, found := c.ctx.HookRelation(); found {
c.Name = r.Name()
}
if len(args) > 0 {
c.Name = args[0]
args = args[1:]
} else if c.Name == "" {
return fmt.Errorf("no relation name specified")
}
return cmd.CheckEmpty(args)
}
func (c *RelationListCommand) Init(f *gnuflag.FlagSet, args []string) (err error) {
c.out.AddFlags(f, "smart", cmd.DefaultFormatters)
if err := f.Parse(true, args); err != nil {
return err
}
args = f.Args()
v := newRelationIdValue(c.ctx, &c.RelationId)
if len(args) > 0 {
if err := v.Set(args[0]); err != nil {
return err
}
args = args[1:]
}
if c.RelationId == -1 {
return fmt.Errorf("no relation id specified")
}
return cmd.CheckEmpty(args)
}
func (c *ResolvedCommand) Init(f *gnuflag.FlagSet, args []string) error {
addEnvironFlags(&c.EnvName, f)
f.BoolVar(&c.Retry, "r", false, "re-execute failed hooks")
f.BoolVar(&c.Retry, "retry", false, "")
if err := f.Parse(true, args); err != nil {
return err
}
args = f.Args()
if len(args) > 0 {
c.UnitName = args[0]
if !state.IsUnitName(c.UnitName) {
return fmt.Errorf("invalid unit name %q", c.UnitName)
}
args = args[1:]
} else {
return fmt.Errorf("no unit specified")
}
return cmd.CheckEmpty(args)
}
func (c *RelationSetCommand) Init(f *gnuflag.FlagSet, args []string) error {
f.Var(newRelationIdValue(c.ctx, &c.RelationId), "r", "specify a relation by id")
if err := f.Parse(true, args); err != nil {
return err
}
if c.RelationId == -1 {
return fmt.Errorf("no relation id specified")
}
args = f.Args()
if len(args) == 0 {
return fmt.Errorf(`expected "key=value" parameters, got nothing`)
}
for _, kv := range args {
parts := strings.SplitN(kv, "=", 2)
if len(parts) != 2 || len(parts[0]) == 0 {
return fmt.Errorf(`expected "key=value", got %q`, kv)
}
c.Settings[parts[0]] = parts[1]
}
return nil
}
func (c *AddUnitCommand) Init(f *gnuflag.FlagSet, args []string) error {
addEnvironFlags(&c.EnvName, f)
f.IntVar(&c.NumUnits, "n", 1, "number of service units to add")
f.IntVar(&c.NumUnits, "num-units", 1, "")
if err := f.Parse(true, args); err != nil {
return err
}
args = f.Args()
switch len(args) {
case 1:
c.ServiceName = args[0]
case 0:
return errors.New("no service specified")
default:
return cmd.CheckEmpty(args[1:])
}
if c.NumUnits < 1 {
return errors.New("must add at least one unit")
}
return nil
}
func (c *UpgradeJujuCommand) Init(f *gnuflag.FlagSet, args []string) error {
addEnvironFlags(&c.EnvName, f)
var vers string
f.BoolVar(&c.UploadTools, "upload-tools", false, "upload local version of tools")
f.StringVar(&vers, "version", "", "version to upgrade to (defaults to highest available version with the current major version number)")
f.BoolVar(&c.BumpVersion, "bump-version", false, "upload the tools with a higher build number if necessary, and use that version (overrides --version)")
f.BoolVar(&c.Development, "dev", false, "allow development versions to be chosen")
if err := f.Parse(true, args); err != nil {
return err
}
if vers != "" {
var err error
c.Version, err = version.Parse(vers)
if err != nil {
return err
}
if c.Version == (version.Number{}) {
return fmt.Errorf("cannot upgrade to version 0.0.0")
}
}
return cmd.CheckEmpty(f.Args())
}
func parseArgs(fset *flag.FlagSet, args []string) (*params, error) {
var p params
var printHeaders, noBody, noCookies bool
fset.BoolVar(&p.json, "j", false, "serialize data items as a JSON object")
fset.BoolVar(&p.json, "json", false, "")
fset.BoolVar(&p.form, "f", false, "serialize data items as form values")
fset.BoolVar(&p.form, "form", false, "")
fset.BoolVar(&printHeaders, "h", false, "print the response headers")
fset.BoolVar(&printHeaders, "headers", false, "")
fset.BoolVar(&noBody, "B", false, "do not print response body")
fset.BoolVar(&noBody, "body", false, "")
fset.BoolVar(&p.debug, "debug", false, "print debugging messages")
fset.BoolVar(&p.noBrowser, "W", false, "do not open macaroon-login URLs in web browser")
fset.BoolVar(&p.noBrowser, "no-browser", false, "")
fset.BoolVar(&p.raw, "raw", false, "print response body without any JSON post-processing")
fset.StringVar(&p.basicAuth, "a", "", "http basic auth (username:password)")
fset.StringVar(&p.basicAuth, "auth", "", "")
fset.BoolVar(&p.insecure, "insecure", false, "skip HTTPS certificate checking")
fset.StringVar(&p.cookieFile, "cookiefile", filepath.Join(os.Getenv("HOME"), ".go-cookies"), "file to store persistent cookies in")
fset.BoolVar(&noCookies, "C", false, "disable cookie storage")
fset.BoolVar(&noCookies, "no-cookies", false, "")
fset.BoolVar(&p.useStdin, "stdin", false, "read request body from standard input")
// TODO --file (multipart upload)
// TODO --timeout
// TODO --proxy
// TODO (??) --verify
fset.Usage = func() {
fmt.Fprint(os.Stderr, helpMessage)
fset.PrintDefaults()
}
if err := fset.Parse(true, args); err != nil {
return nil, err
}
if noCookies {
p.cookieFile = ""
}
p.headers = printHeaders
p.body = !noBody
args = fset.Args()
if len(args) == 0 {
return nil, errUsage
}
if isMethod(args[0]) {
p.method, args = strings.ToUpper(args[0]), args[1:]
if len(args) == 0 {
return nil, errUsage
}
}
urlStr := args[0]
if strings.HasPrefix(urlStr, ":") {
// shorthand for localhost.
if strings.HasPrefix(urlStr, ":/") {
urlStr = "http://localhost" + urlStr[1:]
} else {
urlStr = "http://localhost" + urlStr
}
}
if !strings.HasPrefix(urlStr, "http:") && !strings.HasPrefix(urlStr, "https:") {
urlStr = "http://" + urlStr
}
u, err := url.Parse(urlStr)
if err != nil {
return nil, fmt.Errorf("invalid URL %q: %v", args[0], err)
}
if u.Host == "" {
u.Host = "localhost"
}
p.url, args = u, args[1:]
p.keyVals = make([]keyVal, len(args))
for i, arg := range args {
kv, err := parseKeyVal(arg)
if err != nil {
return nil, fmt.Errorf("cannot parse %q: %v", arg, err)
}
if kv.sep == "=" && p.method == "" {
p.method = "POST"
}
p.keyVals[i] = kv
}
if p.method == "" {
p.method = "GET"
}
return &p, nil
}