From eb7f560afb29d17c34aa815141855c228284a4e3 Mon Sep 17 00:00:00 2001 From: Rene Engelhard Date: Tue, 26 Apr 2016 15:50:22 +0200 Subject: [PATCH 1/6] fleetctl: move to cli - rework option parsing - move away from (most) global variables (cAPI), keep currentCommand for now... - we need to pass c (the cli context) and cAPI (the client API) around Signed-off-by: Olaf Buddenhagen --- fleetctl/cat.go | 23 +- fleetctl/destroy.go | 28 ++- fleetctl/destroy_test.go | 16 +- fleetctl/fdforward.go | 19 +- fleetctl/fleetctl.go | 412 +++++++++++++------------------ fleetctl/fleetctl_test.go | 45 ++-- fleetctl/help.go | 150 ----------- fleetctl/journal.go | 52 ++-- fleetctl/list_machines.go | 54 ++-- fleetctl/list_unit_files.go | 58 +++-- fleetctl/list_unit_files_test.go | 30 ++- fleetctl/list_units.go | 62 ++--- fleetctl/list_units_test.go | 18 +- fleetctl/load.go | 37 +-- fleetctl/load_test.go | 21 +- fleetctl/ssh.go | 109 ++++---- fleetctl/ssh_test.go | 32 +-- fleetctl/start.go | 46 ++-- fleetctl/start_test.go | 19 +- fleetctl/status.go | 31 ++- fleetctl/stop.go | 38 +-- fleetctl/stop_test.go | 22 +- fleetctl/submit.go | 40 +-- fleetctl/submit_test.go | 18 +- fleetctl/unload.go | 31 +-- fleetctl/unload_test.go | 22 +- fleetctl/verify.go | 20 +- fleetctl/version.go | 31 --- 28 files changed, 663 insertions(+), 821 deletions(-) delete mode 100644 fleetctl/help.go delete mode 100644 fleetctl/version.go diff --git a/fleetctl/cat.go b/fleetctl/cat.go index d7cb99dcd..82b578096 100644 --- a/fleetctl/cat.go +++ b/fleetctl/cat.go @@ -17,21 +17,24 @@ package main import ( "fmt" + "github.com/codegangsta/cli" + + "github.com/coreos/fleet/client" "github.com/coreos/fleet/schema" ) -var ( - cmdCatUnit = &Command{ - Name: "cat", - Summary: "Output the contents of a submitted unit", - Usage: "UNIT", - Description: `Outputs the unit file that is currently loaded in the cluster. Useful to verify -the correct version of a unit is running.`, - Run: runCatUnit, +func NewCatCommand() cli.Command { + return cli.Command{ + Name: "cat", + Usage: "Output the contents of a submitted unit", + ArgsUsage: "UNIT", + Description: `Outputs the unit file that is currently loaded in the cluster. Useful to verify the correct version of a unit is running.`, + Action: makeActionWrapper(runCatUnit), } -) +} -func runCatUnit(args []string) (exit int) { +func runCatUnit(c *cli.Context, cAPI client.API) (exit int) { + args := c.Args() if len(args) != 1 { stderr("One unit file must be provided") return 1 diff --git a/fleetctl/destroy.go b/fleetctl/destroy.go index 31eb919b6..b8bf9a441 100644 --- a/fleetctl/destroy.go +++ b/fleetctl/destroy.go @@ -17,30 +17,35 @@ package main import ( "time" + "github.com/codegangsta/cli" + "github.com/coreos/fleet/client" ) -var cmdDestroyUnit = &Command{ - Name: "destroy", - Summary: "Destroy one or more units in the cluster", - Usage: "UNIT...", - Description: `Completely remove one or more running or submitted units from the cluster. +func NewDestroyCommand() cli.Command { + return cli.Command{ + Name: "destroy", + Usage: "Destroy one or more units in the cluster", + ArgsUsage: "UNIT...", + Description: `Completely remove one or more running or submitted units from the cluster. Instructs systemd on the host machine to stop the unit, deferring to systemd completely for any custom stop directives (i.e. ExecStop option in the unit file). Destroyed units are impossible to start unless re-submitted.`, - Run: runDestroyUnits, + Action: makeActionWrapper(runDestroyUnits), + } } -func runDestroyUnits(args []string) (exit int) { +func runDestroyUnits(c *cli.Context, cAPI client.API) (exit int) { + args := c.Args() if len(args) == 0 { stderr("No units given") return 0 } - units, err := findUnits(args) + units, err := findUnits(args, cAPI) if err != nil { stderr("%v", err) return 1 @@ -58,10 +63,10 @@ func runDestroyUnits(args []string) (exit int) { continue } - if !sharedFlags.NoBlock { - attempts := sharedFlags.BlockAttempts + if c.Bool("no-block") { + attempts := c.Int("block-attempts") retry := func() bool { - if sharedFlags.BlockAttempts < 1 { + if c.Int("block-attempts") < 1 { return true } attempts-- @@ -88,5 +93,6 @@ func runDestroyUnits(args []string) (exit int) { stdout("Destroyed %s", v.Name) } + return } diff --git a/fleetctl/destroy_test.go b/fleetctl/destroy_test.go index e10111a9e..7dfde0727 100644 --- a/fleetctl/destroy_test.go +++ b/fleetctl/destroy_test.go @@ -18,10 +18,14 @@ import ( "fmt" "sync" "testing" + + "github.com/codegangsta/cli" + + "github.com/coreos/fleet/client" ) -func doDestroyUnits(r commandTestResults, errchan chan error) { - exit := runDestroyUnits(r.units) +func doDestroyUnits(t *testing.T, r commandTestResults, errchan chan error, cAPI client.API, c *cli.Context) { + exit := runDestroyUnits(c, cAPI) if exit != r.expectedExit { errchan <- fmt.Errorf("%s: expected exit code %d but received %d", r.description, r.expectedExit, exit) return @@ -68,16 +72,18 @@ func TestRunDestroyUnits(t *testing.T) { var wg sync.WaitGroup errchan := make(chan error) - cAPI = newFakeRegistryForCommands(unitPrefix, len(r.units), false) + cAPI := newFakeRegistryForCommands(unitPrefix, len(r.units), false) + + c := createTestContext(t, append([]string{"destroy"}, r.units...)...) wg.Add(2) go func() { defer wg.Done() - doDestroyUnits(r, errchan) + doDestroyUnits(t, r, errchan, cAPI, c) }() go func() { defer wg.Done() - doDestroyUnits(r, errchan) + doDestroyUnits(t, r, errchan, cAPI, c) }() go func() { diff --git a/fleetctl/fdforward.go b/fleetctl/fdforward.go index a44d409f9..55f8b255f 100644 --- a/fleetctl/fdforward.go +++ b/fleetctl/fdforward.go @@ -18,19 +18,24 @@ import ( "io" "net" "os" + + "github.com/codegangsta/cli" + + "github.com/coreos/fleet/client" ) -var ( - cmdFDForward = &Command{ +func NewFDForwardCommand() cli.Command { + return cli.Command{ Name: "fd-forward", - Summary: "Proxy stdin and stdout to a unix domain socket", - Usage: "SOCKET", + Usage: "Proxy stdin and stdout to a unix domain socket", + ArgsUsage: "SOCKET", Description: `fleetctl utilizes fd-forward when --tunnel is used and --endpoint is a unix socket. This command is not intended to be called by users directly.`, - Run: runFDForward, + Action: makeActionWrapper(runFDForward), } -) +} -func runFDForward(args []string) (exit int) { +func runFDForward(c *cli.Context, cAPI client.API) (exit int) { + args := c.Args() if len(args) != 1 { stderr("Provide a single argument") return 1 diff --git a/fleetctl/fleetctl.go b/fleetctl/fleetctl.go index e635a0f78..e7491091a 100644 --- a/fleetctl/fleetctl.go +++ b/fleetctl/fleetctl.go @@ -30,6 +30,8 @@ import ( "text/tabwriter" "time" + "github.com/codegangsta/cli" + etcd "github.com/coreos/etcd/client" "github.com/coreos/fleet/api" @@ -64,50 +66,10 @@ recommended to upgrade fleetctl to prevent incompatibility issues. ) var ( - out *tabwriter.Writer - globalFlagset = flag.NewFlagSet("fleetctl", flag.ExitOnError) - - // set of top-level commands - commands []*Command + out *tabwriter.Writer // global API client used by commands - cAPI client.API - - // flags used by all commands - globalFlags = struct { - Debug bool - Version bool - Help bool - - ClientDriver string - ExperimentalAPI bool - Endpoint string - RequestTimeout float64 - - KeyFile string - CertFile string - CAFile string - - Tunnel string - KnownHostsFile string - StrictHostKeyChecking bool - SSHTimeout float64 - SSHUserName string - - EtcdKeyPrefix string - }{} - - // flags used by multiple commands - sharedFlags = struct { - Sign bool - Full bool - NoLegend bool - NoBlock bool - Replace bool - BlockAttempts int - Fields string - SSHPort int - }{} + // cAPI client.API // current command being executed currentCommand string @@ -116,83 +78,9 @@ var ( machineStates map[string]*machine.MachineState ) -func init() { - // call this as early as possible to ensure we always have timestamps - // on fleetctl logs - log.EnableTimestamps() - - globalFlagset.BoolVar(&globalFlags.Help, "help", false, "Print usage information and exit") - globalFlagset.BoolVar(&globalFlags.Help, "h", false, "Print usage information and exit") - - globalFlagset.BoolVar(&globalFlags.Debug, "debug", false, "Print out more debug information to stderr") - globalFlagset.BoolVar(&globalFlags.Version, "version", false, "Print the version and exit") - globalFlagset.StringVar(&globalFlags.ClientDriver, "driver", clientDriverAPI, fmt.Sprintf("Adapter used to execute fleetctl commands. Options include %q and %q.", clientDriverAPI, clientDriverEtcd)) - globalFlagset.StringVar(&globalFlags.Endpoint, "endpoint", defaultEndpoint, fmt.Sprintf("Location of the fleet API if --driver=%s. Alternatively, if --driver=%s, location of the etcd API.", clientDriverAPI, clientDriverEtcd)) - globalFlagset.StringVar(&globalFlags.EtcdKeyPrefix, "etcd-key-prefix", registry.DefaultKeyPrefix, "Keyspace for fleet data in etcd (development use only!)") - - globalFlagset.StringVar(&globalFlags.KeyFile, "key-file", "", "Location of TLS key file used to secure communication with the fleet API or etcd") - globalFlagset.StringVar(&globalFlags.CertFile, "cert-file", "", "Location of TLS cert file used to secure communication with the fleet API or etcd") - globalFlagset.StringVar(&globalFlags.CAFile, "ca-file", "", "Location of TLS CA file used to secure communication with the fleet API or etcd") - - globalFlagset.StringVar(&globalFlags.KnownHostsFile, "known-hosts-file", ssh.DefaultKnownHostsFile, "File used to store remote machine fingerprints. Ignored if strict host key checking is disabled.") - globalFlagset.BoolVar(&globalFlags.StrictHostKeyChecking, "strict-host-key-checking", true, "Verify host keys presented by remote machines before initiating SSH connections.") - globalFlagset.Float64Var(&globalFlags.SSHTimeout, "ssh-timeout", 10.0, "Amount of time in seconds to allow for SSH connection initialization before failing.") - globalFlagset.StringVar(&globalFlags.Tunnel, "tunnel", "", "Establish an SSH tunnel through the provided address for communication with fleet and etcd.") - globalFlagset.Float64Var(&globalFlags.RequestTimeout, "request-timeout", 3.0, "Amount of time in seconds to allow a single request before considering it failed.") - globalFlagset.StringVar(&globalFlags.SSHUserName, "ssh-username", "core", "Username to use when connecting to CoreOS instance.") - - // deprecated flags - globalFlagset.BoolVar(&globalFlags.ExperimentalAPI, "experimental-api", true, hidden) - globalFlagset.StringVar(&globalFlags.KeyFile, "etcd-keyfile", "", hidden) - globalFlagset.StringVar(&globalFlags.CertFile, "etcd-certfile", "", hidden) - globalFlagset.StringVar(&globalFlags.CAFile, "etcd-cafile", "", hidden) -} - -type Command struct { - Name string // Name of the Command and the string to use to invoke it - Summary string // One-sentence summary of what the Command does - Usage string // Usage options/arguments - Description string // Detailed description of command - Flags flag.FlagSet // Set of flags associated with this command - - Run func(args []string) int // Run a command with the given arguments, return exit status - -} - func init() { out = new(tabwriter.Writer) out.Init(os.Stdout, 0, 8, 1, '\t', 0) - commands = []*Command{ - cmdCatUnit, - cmdDestroyUnit, - cmdFDForward, - cmdHelp, - cmdJournal, - cmdListMachines, - cmdListUnitFiles, - cmdListUnits, - cmdLoadUnits, - cmdSSH, - cmdStartUnit, - cmdStatusUnits, - cmdStopUnit, - cmdSubmitUnit, - cmdUnloadUnit, - cmdVerifyUnit, - cmdVersion, - } -} - -func getAllFlags() (flags []*flag.Flag) { - return getFlags(globalFlagset) -} - -func getFlags(flagset *flag.FlagSet) (flags []*flag.Flag) { - flags = make([]*flag.Flag, 0) - flagset.VisitAll(func(f *flag.Flag) { - flags = append(flags, f) - }) - return } func maybeAddNewline(s string) string { @@ -225,78 +113,108 @@ func checkVersion(cReg registry.ClusterRegistry) (string, bool) { return "", true } -func main() { - // parse global arguments - globalFlagset.Parse(os.Args[1:]) +var ( + globalFlags = []cli.Flag{ + cli.BoolFlag{Name: "debug", Usage: "Print out more debug information to stderr"}, + cli.StringFlag{Name: "driver", Value: clientDriverAPI, Usage: fmt.Sprintf("Adapter used to execute fleetctl commands. Options include %q and %q.", clientDriverAPI, clientDriverEtcd)}, + cli.StringFlag{Name: "endpoint", Value: defaultEndpoint, Usage: fmt.Sprintf("Location of the fleet API if --driver=%s. Alternatively, if --driver=%s, location of the etcd API.", clientDriverAPI, clientDriverEtcd)}, + cli.StringFlag{Name: "etcd-key-prefix", Value: registry.DefaultKeyPrefix, Usage: "Keyspace for fleet data in etcd (development use only!)"}, + cli.StringFlag{Name: "key-file", Value: "", Usage: "Location of TLS key file used to secure communication with the fleet API or etcd"}, + cli.StringFlag{Name: "cert-file", Value: "", Usage: "Location of TLS cert file used to secure communication with the fleet API or etcd"}, + cli.StringFlag{Name: "ca-file", Value: "", Usage: "Location of TLS CA file used to secure communication with the fleet API or etcd"}, + cli.StringFlag{Name: "known-hosts-file", Value: ssh.DefaultKnownHostsFile, Usage: "File used to store remote machine fingerprints. Ignored if strict host key checking is disabled."}, + cli.BoolTFlag{Name: "strict-host-key-checking", Usage: "Verify host keys presented by remote machines before initiating SSH connections."}, + cli.DurationFlag{Name: "ssh-timeout", Value: 10 * time.Second, Usage: "Amount of time in seconds to allow for SSH connection initialization before failing."}, + cli.StringFlag{Name: "tunnel", Value: "", Usage: "Establish an SSH tunnel through the provided address for communication with fleet and etcd."}, + cli.DurationFlag{Name: "request-timeout", Value: 3 * time.Second, Usage: "Amount of time in seconds to allow a single request before considering it failed."}, + cli.StringFlag{Name: "ssh-username", Value: "core", Usage: "Username to use when connecting to CoreOS instance."}, + // deprecated flags + cli.BoolTFlag{Name: "experimental-api", Usage: "DEPRECATED"}, + cli.StringFlag{Name: "etcd-keyfile", Value: "", Usage: "DEPRECATED"}, + cli.StringFlag{Name: "etcd-certfile", Value: "", Usage: "DEPRECATED"}, + cli.StringFlag{Name: "etcd-cafile", Value: "", Usage: "DEPRECATED"}, + } + globalCommands = []cli.Command{ + NewCatCommand(), + NewDestroyCommand(), + NewFDForwardCommand(), + NewJournalCommand(), + NewListMachinesCommand(), + NewListUnitFilesCommand(), + NewListUnitsCommand(), + NewLoadUnitsCommand(), + NewSSHCommend(), + NewStartCommand(), + NewStatusCommand(), + NewStopUnitCommand(), + NewSubmitUnitCommand(), + NewUnloadUnitCommand(), + NewVerifyCommand(), + } +) - var args = globalFlagset.Args() +func createApp() *cli.App { + app := cli.NewApp() + app.Name = "fleetctl" + app.Version = version.Version + app.Usage = "command-line interface to fleet." - getFlagsFromEnv(cliName, globalFlagset) + app.Flags = globalFlags + app.Commands = globalCommands - if globalFlags.Debug { - log.EnableDebug() - } + return app +} - if globalFlags.Version { - args = []string{"version"} - } else if len(args) < 1 || globalFlags.Help { - args = []string{"help"} - } +func main() { + app := createApp() - var cmd *Command + // call this as early as possible to ensure we always have timestamps + // on fleetctl logs + log.EnableTimestamps() - // determine which Command should be run - for _, c := range commands { - if c.Name == args[0] { - cmd = c - if err := c.Flags.Parse(args[1:]); err != nil { - stderr("%v", err) - os.Exit(2) + // determine currentCommand. We only need this for --replace and its + // functional tests, so just handle those for now in the switch... + // "The rest" doesn't care about "currentCommand" + //stderr("%d command line arguments", len(os.Args)) + //stderr("%s", os.Args) + if len(os.Args) > 1 { + for i := 1; i < len(os.Args); i++ { + switch os.Args[i] { + case "start": + currentCommand = "start" + case "load": + currentCommand = "load" + case "submit": + currentCommand = "submit" + default: + continue } - break } + // stderr("First: %s", os.Args[1]) } + app.Run(os.Args) +} - if cmd == nil { - stderr("%v: unknown subcommand: %q", cliName, args[0]) - stderr("Run '%v help' for usage.", cliName) - os.Exit(2) - } - - if sharedFlags.Sign { - stderr("WARNING: The signed/verified units feature is DEPRECATED and cannot be used.") - os.Exit(2) +func getClientAPI(c *cli.Context) client.API { + cAPI, err := getClient(c) + if err != nil { + stderr("Unable to initialize client: %v", err) + os.Exit(1) } + return cAPI +} - visited := make(map[string]bool, 0) - globalFlagset.Visit(func(f *flag.Flag) { visited[f.Name] = true }) - - // if --driver is not set, but --endpoint looks like an etcd - // server, set the driver to etcd - if visited["endpoint"] && !visited["driver"] { - if u, err := url.Parse(strings.Split(globalFlags.Endpoint, ",")[0]); err == nil { - if _, port, err := net.SplitHostPort(u.Host); err == nil && (port == "4001" || port == "2379") { - log.Debugf("Defaulting to --driver=%s as --endpoint appears to be etcd", clientDriverEtcd) - globalFlags.ClientDriver = clientDriverEtcd - } +func makeActionWrapper(action func(context *cli.Context, cAPI client.API) int) func(context *cli.Context) { + return func(c *cli.Context) { + if c.Bool("sign") { + stderr("WARNING: The signed/verified units feature is DEPRECATED and cannot be used.") + os.Exit(2) } - } - - if cmd.Name != "help" && cmd.Name != "version" { - var err error - cAPI, err = getClient() - if err != nil { - stderr("Unable to initialize client: %v", err) - os.Exit(1) + cAPI := getClientAPI(c) + if ret := action(c, cAPI); ret != 0 { + os.Exit(ret) } } - - // We use this to know in which context we are, - // submit, load or start - currentCommand = cmd.Name - - os.Exit(cmd.Run(cmd.Flags.Args())) - } // getFlagsFromEnv parses all registered flags in the given flagset, @@ -322,31 +240,44 @@ func getFlagsFromEnv(prefix string, fs *flag.FlagSet) { } // getClient initializes a client of fleet based on CLI flags -func getClient() (client.API, error) { +func getClient(c *cli.Context) (client.API, error) { + driverFlag := c.GlobalString("driver") + // if --driver is not set, but --endpoint looks like an etcd + // server, set the driver to etcd + if c.GlobalIsSet("endpoint") && !c.GlobalIsSet("driver") { + if u, err := url.Parse(strings.Split(c.GlobalString("endpoint"), ",")[0]); err == nil { + if _, port, err := net.SplitHostPort(u.Host); err == nil && (port == "4001" || port == "2379") { + log.Debugf("Defaulting to --driver=%s as --endpoint appears to be etcd", clientDriverEtcd) + driverFlag = clientDriverEtcd + } + } + } + + endpointFlag := c.GlobalString("endpoint") // The user explicitly set --experimental-api=false, so it trumps the // --driver flag. This behavior exists for backwards-compatibilty. - if !globalFlags.ExperimentalAPI { + if !c.GlobalBool("experimental-api") { // Additionally, if the user set --experimental-api=false and did // not change the value of --endpoint, they likely want to use the // old default value. - if globalFlags.Endpoint == defaultEndpoint { - globalFlags.Endpoint = "http://127.0.0.1:2379,http://127.0.0.1:4001" + if endpointFlag == defaultEndpoint { + endpointFlag = "http://127.0.0.1:2379,http://127.0.0.1:4001" } - return getRegistryClient() + return getRegistryClient(c) } - switch globalFlags.ClientDriver { + switch driverFlag { case clientDriverAPI: - return getHTTPClient() + return getHTTPClient(c, endpointFlag) case clientDriverEtcd: - return getRegistryClient() + return getRegistryClient(c) } - return nil, fmt.Errorf("unrecognized driver %q", globalFlags.ClientDriver) + return nil, fmt.Errorf("unrecognized driver %q", driverFlag) } -func getHTTPClient() (client.API, error) { - endpoints := strings.Split(globalFlags.Endpoint, ",") +func getHTTPClient(c *cli.Context, endpointFlag string) (client.API, error) { + endpoints := strings.Split(endpointFlag, ",") if len(endpoints) > 1 { log.Warningf("multiple endpoints provided but only the first (%s) is used", endpoints[0]) } @@ -360,14 +291,14 @@ func getHTTPClient() (client.API, error) { return nil, errors.New("URL scheme undefined") } - tun := getTunnelFlag() + tun := getTunnelFlag(c) tunneling := tun != "" dialUnix := ep.Scheme == "unix" || ep.Scheme == "file" tunnelFunc := net.Dial if tunneling { - sshClient, err := ssh.NewSSHClient(globalFlags.SSHUserName, tun, getChecker(), true, getSSHTimeoutFlag()) + sshClient, err := ssh.NewSSHClient(c.GlobalString("ssh-username"), tun, getChecker(c), true, getSSHTimeoutFlag(c)) if err != nil { return nil, fmt.Errorf("failed initializing SSH client: %v", err) } @@ -414,7 +345,7 @@ func getHTTPClient() (client.API, error) { ep.Host = "domain-sock" } - tlsConfig, err := pkg.ReadTLSConfigFiles(globalFlags.CAFile, globalFlags.CertFile, globalFlags.KeyFile) + tlsConfig, err := pkg.ReadTLSConfigFiles(c.GlobalString("ca-file"), c.GlobalString("cert-file"), c.GlobalString("key-file")) if err != nil { return nil, err } @@ -433,11 +364,11 @@ func getHTTPClient() (client.API, error) { return client.NewHTTPClient(&hc, *ep) } -func getRegistryClient() (client.API, error) { +func getRegistryClient(c *cli.Context) (client.API, error) { var dial func(string, string) (net.Conn, error) - tun := getTunnelFlag() + tun := getTunnelFlag(c) if tun != "" { - sshClient, err := ssh.NewSSHClient(globalFlags.SSHUserName, tun, getChecker(), false, getSSHTimeoutFlag()) + sshClient, err := ssh.NewSSHClient(c.GlobalString("ssh-username"), tun, getChecker(c), false, getSSHTimeoutFlag(c)) if err != nil { return nil, fmt.Errorf("failed initializing SSH client: %v", err) } @@ -451,7 +382,7 @@ func getRegistryClient() (client.API, error) { } } - tlsConfig, err := pkg.ReadTLSConfigFiles(globalFlags.CAFile, globalFlags.CertFile, globalFlags.KeyFile) + tlsConfig, err := pkg.ReadTLSConfigFiles(c.GlobalString("ca-file"), c.GlobalString("cert-file"), c.GlobalString("key-file")) if err != nil { return nil, err } @@ -462,7 +393,7 @@ func getRegistryClient() (client.API, error) { } eCfg := etcd.Config{ - Endpoints: strings.Split(globalFlags.Endpoint, ","), + Endpoints: strings.Split(c.GlobalString("endpoint"), ","), Transport: trans, HeaderTimeoutPerRequest: getRequestTimeoutFlag(), } @@ -473,7 +404,7 @@ func getRegistryClient() (client.API, error) { } kAPI := etcd.NewKeysAPI(eClient) - reg := registry.NewEtcdRegistry(kAPI, globalFlags.EtcdKeyPrefix) + reg := registry.NewEtcdRegistry(kAPI, c.GlobalString("etcd-key-prefix")) if msg, ok := checkVersion(reg); !ok { stderr(msg) @@ -483,12 +414,12 @@ func getRegistryClient() (client.API, error) { } // getChecker creates and returns a HostKeyChecker, or nil if any error is encountered -func getChecker() *ssh.HostKeyChecker { - if !globalFlags.StrictHostKeyChecking { +func getChecker(c *cli.Context) *ssh.HostKeyChecker { + if !c.GlobalBool("strict-host-key-checking") { return nil } - keyFile := ssh.NewHostKeyFile(globalFlags.KnownHostsFile) + keyFile := ssh.NewHostKeyFile(c.GlobalString("known-hosts-file")) return ssh.NewHostKeyChecker(keyFile) } @@ -499,7 +430,7 @@ func getChecker() *ssh.HostKeyChecker { // tries to get the template configuration either from the registry or // the local disk. // It returns a UnitFile configuration or nil; and any error ecountered -func getUnitFile(file string) (*unit.UnitFile, error) { +func getUnitFile(file string, cAPI client.API, c *cli.Context) (*unit.UnitFile, error) { var uf *unit.UnitFile name := unitNameMangle(file) @@ -527,7 +458,7 @@ func getUnitFile(file string) (*unit.UnitFile, error) { // If we found a template unit, later we create a // near-identical instance unit in the Registry - same // unit file as the template, but different name - uf, err = getUnitFileFromTemplate(info, file) + uf, err = getUnitFileFromTemplate(info, file, cAPI, c) if err != nil { return nil, fmt.Errorf("failed getting Unit(%s) from template: %v", file, err) } @@ -555,7 +486,7 @@ func getUnitFromFile(file string) (*unit.UnitFile, error) { // is either in the registry or on the file system // It takes two arguments, the template information and the unit file name // It returns the Unit or nil; and any error encountered -func getUnitFileFromTemplate(uni *unit.UnitNameInfo, fileName string) (*unit.UnitFile, error) { +func getUnitFileFromTemplate(uni *unit.UnitNameInfo, fileName string, cAPI client.API, c *cli.Context) (*unit.UnitFile, error) { var uf *unit.UnitFile tmpl, err := cAPI.Unit(uni.Template) @@ -564,7 +495,7 @@ func getUnitFileFromTemplate(uni *unit.UnitNameInfo, fileName string) (*unit.Uni } if tmpl != nil { - isLocalUnitDifferent(fileName, tmpl, false) + isLocalUnitDifferent(fileName, tmpl, false, c) uf = schema.MapSchemaUnitOptionsToUnitFile(tmpl.Options) log.Debugf("Template Unit(%s) found in registry", uni.Template) } else { @@ -584,20 +515,20 @@ func getUnitFileFromTemplate(uni *unit.UnitNameInfo, fileName string) (*unit.Uni return uf, nil } -func getTunnelFlag() string { - tun := globalFlags.Tunnel +func getTunnelFlag(c *cli.Context) string { + tun := c.GlobalString("tunnel") if tun != "" && !strings.Contains(tun, ":") { tun += ":22" } return tun } -func getSSHTimeoutFlag() time.Duration { - return time.Duration(globalFlags.SSHTimeout*1000) * time.Millisecond +func getSSHTimeoutFlag(c *cli.Context) time.Duration { + return c.GlobalDuration("ssh-timeout") } -func getRequestTimeoutFlag() time.Duration { - return time.Duration(globalFlags.RequestTimeout*1000) * time.Millisecond +func getRequestTimeoutFlag(c *cli.Context) time.Duration { + return c.GlobalDuration("request-timeout") } func machineIDLegend(ms machine.MachineState, full bool) string { @@ -616,7 +547,7 @@ func machineFullLegend(ms machine.MachineState, full bool) string { return legend } -func findUnits(args []string) (sus []schema.Unit, err error) { +func findUnits(args []string, cAPI client.API) (sus []schema.Unit, err error) { units, err := cAPI.Units() if err != nil { return nil, err @@ -641,7 +572,7 @@ func findUnits(args []string) (sus []schema.Unit, err error) { return filtered, nil } -func createUnit(name string, uf *unit.UnitFile) (*schema.Unit, error) { +func createUnit(name string, uf *unit.UnitFile, cAPI client.API) (*schema.Unit, error) { if uf == nil { return nil, fmt.Errorf("nil unit provided") } @@ -716,7 +647,7 @@ func checkReplaceUnitState(unit *schema.Unit) (int, error) { // It takes a unit file path as a parameter. // It returns 0 on success and if the unit should be created, 1 if the // unit should not be created; and any error encountered. -func checkUnitCreation(arg string) (int, error) { +func checkUnitCreation(arg string, c *cli.Context, cAPI client.API) (int, error) { name := unitNameMangle(arg) // First, check if there already exists a Unit by the given name in the Registry @@ -727,7 +658,7 @@ func checkUnitCreation(arg string) (int, error) { // check if the unit is running if unit == nil { - if sharedFlags.Replace { + if c.Bool("replace") { log.Debugf("Unit(%s) was not found in Registry", name) } // Create a new unit @@ -736,10 +667,10 @@ func checkUnitCreation(arg string) (int, error) { // if sharedFlags.Replace is not set then we warn in case // the units differ - different, err := isLocalUnitDifferent(arg, unit, false) + different, err := isLocalUnitDifferent(arg, unit, false, c) // if sharedFlags.Replace is set then we fail for errors - if sharedFlags.Replace { + if c.Bool("replace") { if err != nil { return 1, err } else if different { @@ -764,14 +695,15 @@ func checkUnitCreation(arg string) (int, error) { // Any error encountered during these steps is returned immediately (i.e. // subsequent Jobs are not acted on). An error is also returned if none of the // above conditions match a given Job. -func lazyCreateUnits(args []string) error { +func lazyCreateUnits(c *cli.Context, cAPI client.API) error { + args := c.Args() errchan := make(chan error) var wg sync.WaitGroup for _, arg := range args { arg = maybeAppendDefaultUnitType(arg) name := unitNameMangle(arg) - ret, err := checkUnitCreation(arg) + ret, err := checkUnitCreation(arg, c, cAPI) if err != nil { return err } else if ret != 0 { @@ -781,18 +713,18 @@ func lazyCreateUnits(args []string) error { // Assume that the name references a local unit file on // disk or if it is an instance unit and if so get its // corresponding unit - uf, err := getUnitFile(arg) + uf, err := getUnitFile(arg, cAPI, c) if err != nil { return err } - _, err = createUnit(name, uf) + _, err = createUnit(name, uf, cAPI) if err != nil { return err } wg.Add(1) - go checkUnitState(name, job.JobStateInactive, sharedFlags.BlockAttempts, os.Stdout, &wg, errchan) + go checkUnitState(name, job.JobStateInactive, c.Int("block-attempts"), os.Stdout, &wg, errchan, cAPI) } go func() { @@ -844,11 +776,11 @@ func matchLocalFileAndUnit(file string, su *schema.Unit) (bool, error) { // happen. // Returns true if the local Unit on file system is different from the // one provided, false otherwise; and any error encountered. -func isLocalUnitDifferent(file string, su *schema.Unit, fatal bool) (bool, error) { +func isLocalUnitDifferent(file string, su *schema.Unit, fatal bool, c *cli.Context) (bool, error) { result, err := matchLocalFileAndUnit(file, su) if err == nil { // Warn in case unit differs from local file - if result == false && !sharedFlags.Replace { + if result == false && !c.Bool("replace") { stderr("WARNING: Unit %s in registry differs from local unit file %s. Add --replace to override.", su.Name, file) } return !result, nil @@ -867,7 +799,7 @@ func isLocalUnitDifferent(file string, su *schema.Unit, fatal bool) (bool, error result, err = matchLocalFileAndUnit(templFile, su) if err == nil { // Warn in case unit differs from local template unit file - if result == false && !sharedFlags.Replace { + if result == false && !c.Bool("replace") { stderr("WARNING: Unit %s in registry differs from local template unit file %s. Add --replace to override.", su.Name, file) } return !result, nil @@ -876,27 +808,27 @@ func isLocalUnitDifferent(file string, su *schema.Unit, fatal bool) (bool, error return false, err } -func lazyLoadUnits(args []string) ([]*schema.Unit, error) { +func lazyLoadUnits(args []string, cAPI client.API) ([]*schema.Unit, error) { units := make([]string, 0, len(args)) for _, j := range args { units = append(units, unitNameMangle(j)) } - return setTargetStateOfUnits(units, job.JobStateLoaded) + return setTargetStateOfUnits(units, job.JobStateLoaded, cAPI) } -func lazyStartUnits(args []string) ([]*schema.Unit, error) { +func lazyStartUnits(args []string, cAPI client.API) ([]*schema.Unit, error) { units := make([]string, 0, len(args)) for _, j := range args { units = append(units, unitNameMangle(j)) } - return setTargetStateOfUnits(units, job.JobStateLaunched) + return setTargetStateOfUnits(units, job.JobStateLaunched, cAPI) } // setTargetStateOfUnits ensures that the target state for the given Units is set // to the given state in the Registry. // On success, a slice of the Units for which a state change was made is returned. // Any error encountered is immediately returned (i.e. this is not a transaction). -func setTargetStateOfUnits(units []string, state job.JobState) ([]*schema.Unit, error) { +func setTargetStateOfUnits(units []string, state job.JobState, cAPI client.API) ([]*schema.Unit, error) { triggered := make([]*schema.Unit, 0) for _, name := range units { u, err := cAPI.Unit(name) @@ -924,15 +856,15 @@ func setTargetStateOfUnits(units []string, state job.JobState) ([]*schema.Unit, // It returns a negative value which means do not block, if zero is // returned then it means try forever, and if a positive value is // returned then try up to that value -func getBlockAttempts() int { +func getBlockAttempts(c *cli.Context) int { // By default we wait forever var attempts int = 0 - if sharedFlags.BlockAttempts > 0 { - attempts = sharedFlags.BlockAttempts + if c.Int("block-attempts") > 0 { + attempts = c.Int("block-attempts") } - if sharedFlags.NoBlock { + if c.Bool("no-block") { attempts = -1 } @@ -949,7 +881,7 @@ func getBlockAttempts() int { // If maxAttempts is zero tryWaitForUnitStates will retry forever, and // if it is greater than zero, it will retry up to the indicated value. // It returns 0 on success or 1 on errors. -func tryWaitForUnitStates(units []string, state string, js job.JobState, maxAttempts int, out io.Writer) (ret int) { +func tryWaitForUnitStates(units []string, state string, js job.JobState, maxAttempts int, out io.Writer, cAPI client.API) (ret int) { // We do not wait just assume we reached the desired state if maxAttempts <= -1 { for _, name := range units { @@ -958,7 +890,7 @@ func tryWaitForUnitStates(units []string, state string, js job.JobState, maxAtte return } - errchan := waitForUnitStates(units, js, maxAttempts, out) + errchan := waitForUnitStates(units, js, maxAttempts, out, cAPI) for err := range errchan { stderr("Error waiting for units: %v", err) ret = 1 @@ -974,12 +906,12 @@ func tryWaitForUnitStates(units []string, state string, js job.JobState, maxAtte // than zero. Returned is an error channel used to communicate when // timeouts occur. The returned error channel will be closed after all // polling operation is complete. -func waitForUnitStates(units []string, js job.JobState, maxAttempts int, out io.Writer) chan error { +func waitForUnitStates(units []string, js job.JobState, maxAttempts int, out io.Writer, cAPI client.API) chan error { errchan := make(chan error) var wg sync.WaitGroup for _, name := range units { wg.Add(1) - go checkUnitState(name, js, maxAttempts, out, &wg, errchan) + go checkUnitState(name, js, maxAttempts, out, &wg, errchan, cAPI) } go func() { @@ -990,21 +922,21 @@ func waitForUnitStates(units []string, js job.JobState, maxAttempts int, out io. return errchan } -func checkUnitState(name string, js job.JobState, maxAttempts int, out io.Writer, wg *sync.WaitGroup, errchan chan error) { +func checkUnitState(name string, js job.JobState, maxAttempts int, out io.Writer, wg *sync.WaitGroup, errchan chan error, cAPI client.API) { defer wg.Done() sleep := defaultSleepTime if maxAttempts < 1 { for { - if assertUnitState(name, js, out) { + if assertUnitState(name, js, out, cAPI) { return } time.Sleep(sleep) } } else { for attempt := 0; attempt < maxAttempts; attempt++ { - if assertUnitState(name, js, out) { + if assertUnitState(name, js, out, cAPI) { return } time.Sleep(sleep) @@ -1013,7 +945,7 @@ func checkUnitState(name string, js job.JobState, maxAttempts int, out io.Writer } } -func assertUnitState(name string, js job.JobState, out io.Writer) (ret bool) { +func assertUnitState(name string, js job.JobState, out io.Writer, cAPI client.API) (ret bool) { var state string u, err := cAPI.Unit(name) @@ -1042,7 +974,7 @@ func assertUnitState(name string, js job.JobState, out io.Writer) (ret bool) { msg := fmt.Sprintf("Unit %s %s", name, u.CurrentState) if u.MachineID != "" { - ms := cachedMachineState(u.MachineID) + ms := cachedMachineState(u.MachineID, cAPI) if ms != nil { msg = fmt.Sprintf("%s on %s", msg, machineFullLegend(*ms, false)) } @@ -1052,7 +984,7 @@ func assertUnitState(name string, js job.JobState, out io.Writer) (ret bool) { return } -func machineState(machID string) (*machine.MachineState, error) { +func machineState(machID string, cAPI client.API) (*machine.MachineState, error) { machines, err := cAPI.Machines() if err != nil { return nil, err @@ -1068,7 +1000,7 @@ func machineState(machID string) (*machine.MachineState, error) { // cachedMachineState makes a best-effort to retrieve the MachineState of the given machine ID. // It memoizes MachineState information for the life of a fleetctl invocation. // Any error encountered retrieving the list of machines is ignored. -func cachedMachineState(machID string) (ms *machine.MachineState) { +func cachedMachineState(machID string, cAPI client.API) (ms *machine.MachineState) { if machineStates == nil { machineStates = make(map[string]*machine.MachineState) ms, err := cAPI.Machines() diff --git a/fleetctl/fleetctl_test.go b/fleetctl/fleetctl_test.go index b8340c906..b126e4965 100644 --- a/fleetctl/fleetctl_test.go +++ b/fleetctl/fleetctl_test.go @@ -27,6 +27,7 @@ import ( "github.com/coreos/fleet/version" "github.com/coreos/go-semver/semver" + "github.com/codegangsta/cli" ) type commandTestResults struct { @@ -139,6 +140,26 @@ func newFakeRegistryForCheckVersion(v string) registry.ClusterRegistry { return registry.NewFakeClusterRegistry(sv, 0) } +func createTestContext(t *testing.T, args ...string) *cli.Context { + var c *cli.Context + app := createApp() + + stderr("args: %v", args) + action := func(ctx *cli.Context) { + c = ctx + } + app.Action = action + for i := range app.Commands { + app.Commands[i].Action = action + } + + if err := app.Run(append([]string{"fleetctl"}, args...)); err != nil { + t.Fatalf("Run error: %s", err) + } + + return c +} + func TestCheckVersion(t *testing.T) { reg := newFakeRegistryForCheckVersion(version.Version) _, ok := checkVersion(reg) @@ -222,14 +243,6 @@ func TestUnitNameMangle(t *testing.T) { } func TestGetBlockAttempts(t *testing.T) { - oldNoBlock := sharedFlags.NoBlock - oldBlockAttempts := sharedFlags.BlockAttempts - - defer func() { - sharedFlags.NoBlock = oldNoBlock - sharedFlags.BlockAttempts = oldBlockAttempts - }() - var blocktests = []struct { noBlock bool blockAttempts int @@ -244,10 +257,14 @@ func TestGetBlockAttempts(t *testing.T) { } for _, tt := range blocktests { - sharedFlags.NoBlock = tt.noBlock - sharedFlags.BlockAttempts = tt.blockAttempts - if n := getBlockAttempts(); n != tt.expected { - t.Errorf("got %d, want %d", n, tt.expected) + var c *cli.Context + if tt.noBlock { + c = createTestContext(t, "load", "--no-block", "--block-attempts", fmt.Sprintf("%d", tt.blockAttempts), "none") + } else { + c = createTestContext(t, "load", "--block-attempts", fmt.Sprintf("%d", tt.blockAttempts), "none") + } + if n := getBlockAttempts(c); n != tt.expected { + t.Errorf("got %d, want %d (for --no-block=%t, --block-attempts=%d)", n, tt.expected, tt.noBlock, tt.blockAttempts) } } } @@ -264,7 +281,7 @@ func TestCreateUnitFails(t *testing.T) { type fakeAPI struct { client.API } - cAPI = fakeAPI{} + cAPI := fakeAPI{} var i int var un string var uf *unit.UnitFile @@ -331,7 +348,7 @@ Conflicts=bar`), for i, tt = range testCases { un = tt.name uf = tt.uf - if _, err := createUnit(un, uf); err == nil { + if _, err := createUnit(un, uf, cAPI); err == nil { t.Errorf("case %d did not return error as expected!", i) t.Logf("unit name: %v", un) t.Logf("unit file: %#v", uf) diff --git a/fleetctl/help.go b/fleetctl/help.go deleted file mode 100644 index 61a10b683..000000000 --- a/fleetctl/help.go +++ /dev/null @@ -1,150 +0,0 @@ -// Copyright 2014 CoreOS, Inc. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package main - -import ( - "flag" - "fmt" - "strings" - "text/template" - - "github.com/coreos/fleet/version" -) - -const ( - // used to indicate flag usage should not be printed - hidden = "hidden" -) - -var ( - cmdHelp = &Command{ - Name: "help", - Summary: "Show a list of commands or help for one command", - Usage: "[COMMAND]", - Description: "Show a list of commands or detailed help for one command", - Run: runHelp, - } - - globalUsageTemplate *template.Template - commandUsageTemplate *template.Template - templFuncs = template.FuncMap{ - "descToLines": func(s string) []string { - // trim leading/trailing whitespace and split into slice of lines - return strings.Split(strings.Trim(s, "\n\t "), "\n") - }, - "printOption": func(name, defvalue, usage string) string { - if usage == hidden { - return "" - } - prefix := "--" - if len(name) == 1 { - prefix = "-" - } - return fmt.Sprintf("\n\t%s%s=%s\t%s", prefix, name, defvalue, usage) - }, - } -) - -func init() { - globalUsageTemplate = template.Must(template.New("global_usage").Funcs(templFuncs).Parse(` -NAME: -{{printf "\t%s - %s" .Executable .Description}} - -USAGE: -{{printf "\t%s" .Executable}} [global options] [command options] [arguments...] - -VERSION: -{{printf "\t%s" .Version}} - -COMMANDS:{{range .Commands}} -{{printf "\t%s\t%s" .Name .Summary}}{{end}} - -GLOBAL OPTIONS:{{range .Flags}}{{printOption .Name .DefValue .Usage}}{{end}} - -Global options can also be configured via upper-case environment variables prefixed with "FLEETCTL_" -For example, "some-flag" => "FLEETCTL_SOME_FLAG" - -Run "{{.Executable}} help " for more details on a specific command. -`[1:])) - commandUsageTemplate = template.Must(template.New("command_usage").Funcs(templFuncs).Parse(` -NAME: -{{printf "\t%s - %s" .Cmd.Name .Cmd.Summary}} - -USAGE: -{{printf "\t%s %s %s" .Executable .Cmd.Name .Cmd.Usage}} - -DESCRIPTION: -{{range $line := descToLines .Cmd.Description}}{{printf "\t%s" $line}} -{{end}} -{{if .CmdFlags}}OPTIONS:{{range .CmdFlags}} -{{printOption .Name .DefValue .Usage}}{{end}} - -{{end}}For help on global options run "{{.Executable}} help" -`[1:])) -} - -func runHelp(args []string) (exit int) { - if len(args) < 1 { - printGlobalUsage() - return - } - - var cmd *Command - - for _, c := range commands { - if c.Name == args[0] { - cmd = c - break - } - } - - if cmd == nil { - stderr("Unrecognized command: %s", args[0]) - return 1 - } - - printCommandUsage(cmd) - return -} - -func printGlobalUsage() { - globalUsageTemplate.Execute(out, struct { - Executable string - Commands []*Command - Flags []*flag.Flag - Description string - Version string - }{ - cliName, - commands, - getAllFlags(), - cliDescription, - version.Version, - }) - out.Flush() -} - -func printCommandUsage(cmd *Command) { - commandUsageTemplate.Execute(out, struct { - Executable string - Cmd *Command - CmdFlags []*flag.Flag - }{ - cliName, - cmd, - getFlags(&cmd.Flags), - }) - out.Flush() -} diff --git a/fleetctl/journal.go b/fleetctl/journal.go index 6bececba3..d0a249039 100644 --- a/fleetctl/journal.go +++ b/fleetctl/journal.go @@ -17,41 +17,39 @@ package main import ( "strconv" + "github.com/codegangsta/cli" + + "github.com/coreos/fleet/client" "github.com/coreos/fleet/job" ) -var ( - flagLines int - flagFollow bool - flagSudo bool - flagOutput string - cmdJournal = &Command{ - Name: "journal", - Summary: "Print the journal of a unit in the cluster to stdout", - Usage: "[--lines=N] [--ssh-port=N] [-f|--follow] [--output=STRING] ", - Run: runJournal, - Description: `Outputs the journal of a unit by connecting to the machine that the unit occupies. +func NewJournalCommand() cli.Command { + return cli.Command{ + Name: "journal", + Usage: "Print the journal of a unit in the cluster to stdout", + ArgsUsage: "[--lines=N] [--ssh-port=N] [-f|--follow] [--output=STRING] ", + Action: makeActionWrapper(runJournal), + Description: `Outputs the journal of a unit by connecting to the machine that the unit occupies. Read the last 10 lines: - fleetctl journal foo.service + fleetctl journal foo.service Read the last 100 lines: - fleetctl journal --lines 100 foo.service + fleetctl journal --lines 100 foo.service This command does not work with global units.`, + Flags: []cli.Flag{ + cli.IntFlag{Name: "lines", Value: 10, Usage: "Number of recent log lines to return"}, + cli.BoolFlag{Name: "follow, f", Usage: "Continuously print new entries as they are appended to the journal."}, + cli.IntFlag{Name: "ssh-port", Value: 22, Usage: "Connect to remote hosts over SSH using this TCP port"}, + cli.BoolFlag{Name: "sudo", Usage: "Execute journal command with sudo"}, + cli.StringFlag{Name: "output", Value: "short", Usage: "Output mode. This will be passed unaltered to journalctl on the remote host, and hence supports the same modes as that command."}, + }, } -) - -func init() { - cmdJournal.Flags.IntVar(&flagLines, "lines", 10, "Number of recent log lines to return") - cmdJournal.Flags.BoolVar(&flagFollow, "follow", false, "Continuously print new entries as they are appended to the journal.") - cmdJournal.Flags.BoolVar(&flagFollow, "f", false, "Shorthand for --follow") - cmdJournal.Flags.IntVar(&sharedFlags.SSHPort, "ssh-port", 22, "Connect to remote hosts over SSH using this TCP port") - cmdJournal.Flags.BoolVar(&flagSudo, "sudo", false, "Execute journal command with sudo") - cmdJournal.Flags.StringVar(&flagOutput, "output", "short", "Output mode. This will be passed unaltered to journalctl on the remote host, and hence supports the same modes as that command.") } -func runJournal(args []string) (exit int) { +func runJournal(c *cli.Context, cAPI client.API) (exit int) { + args := c.Args() if len(args) != 1 { stderr("One unit file must be provided.") return 1 @@ -73,15 +71,15 @@ func runJournal(args []string) (exit int) { return 1 } - cmd := []string{"journalctl", "--unit", name, "--no-pager", "-n", strconv.Itoa(flagLines), "--output", flagOutput} + cmd := []string{"journalctl", "--unit", name, "--no-pager", "-n", strconv.Itoa(c.Int("lines")), "--output", c.String("output")} - if flagSudo { + if c.Bool("sudo") { cmd = append([]string{"sudo"}, cmd...) } - if flagFollow { + if c.Bool("follow") { cmd = append(cmd, "-f") } - return runCommand(u.MachineID, cmd[0], cmd[1:]...) + return runCommand(c, cAPI, u.MachineID, cmd[0], cmd[1:]...) } diff --git a/fleetctl/list_machines.go b/fleetctl/list_machines.go index 86368d46b..8b83bf296 100644 --- a/fleetctl/list_machines.go +++ b/fleetctl/list_machines.go @@ -19,29 +19,36 @@ import ( "sort" "strings" - "github.com/coreos/fleet/machine" -) + "github.com/codegangsta/cli" -const ( - defaultListMachinesFields = "machine,ip,metadata" + "github.com/coreos/fleet/client" + "github.com/coreos/fleet/machine" ) -var ( - listMachinesFieldsFlag string - cmdListMachines = &Command{ - Name: "list-machines", - Summary: "Enumerate the current hosts in the cluster", - Usage: "[-l|--full] [--no-legend]", +func NewListMachinesCommand() cli.Command { + return cli.Command{ + Name: "list-machines", + Usage: "Enumerate the current hosts in the cluster", Description: `Lists all active machines within the cluster. Previously active machines will not appear in this list. For easily parsable output, you can remove the column headers: - fleetctl list-machines --no-legend + fleetctl list-machines --no-legend Output the list without truncation: - fleetctl list-machines --full`, - Run: runListMachines, + fleetctl list-machines --full`, + ArgsUsage: "[-l|--full] [--no-legend]", + Action: makeActionWrapper(runListMachines), + Flags: []cli.Flag{ + cli.BoolFlag{Name: "full, l", Usage: "Output the list without truncation"}, + cli.BoolFlag{Name: "no-legend", Usage: "Remove the column headers"}, + cli.StringFlag{Name: "fields", Value: defaultListMachinesFields, Usage: fmt.Sprintf("Columns to print for each Machine. Valid fields are %s", defaultListMachinesFields)}, + }, } +} +var ( + //listMachinesFieldsFlag string + // Update defaultListMachinesFields if you add a new field here listMachinesFields = map[string]machineToField{ "machine": func(ms *machine.MachineState, full bool) string { return machineIDLegend(*ms, full) @@ -61,16 +68,14 @@ Output the list without truncation: } ) -type machineToField func(ms *machine.MachineState, full bool) string +const ( + defaultListMachinesFields = "machine,ip,metadata" +) -func init() { - cmdListMachines.Flags.BoolVar(&sharedFlags.Full, "full", false, "Do not ellipsize fields on output") - cmdListMachines.Flags.BoolVar(&sharedFlags.Full, "l", false, "Shorthand for --full") - cmdListMachines.Flags.BoolVar(&sharedFlags.NoLegend, "no-legend", false, "Do not print a legend (column headers)") - cmdListMachines.Flags.StringVar(&listMachinesFieldsFlag, "fields", defaultListMachinesFields, fmt.Sprintf("Columns to print for each Machine. Valid fields are %q", strings.Join(machineToFieldKeys(listMachinesFields), ","))) -} +type machineToField func(ms *machine.MachineState, full bool) string -func runListMachines(args []string) (exit int) { +func runListMachines(c *cli.Context, cAPI client.API) (exit int) { + listMachinesFieldsFlag := c.String("fields") if listMachinesFieldsFlag == "" { stderr("Must define output format") return 1 @@ -90,20 +95,21 @@ func runListMachines(args []string) (exit int) { return 1 } - if !sharedFlags.NoLegend { + if !c.Bool("no-legend") { fmt.Fprintln(out, strings.ToUpper(strings.Join(cols, "\t"))) } for _, ms := range machines { ms := ms var f []string - for _, c := range cols { - f = append(f, listMachinesFields[c](&ms, sharedFlags.Full)) + for _, col := range cols { + f = append(f, listMachinesFields[col](&ms, c.Bool("full"))) } fmt.Fprintln(out, strings.Join(f, "\t")) } out.Flush() + return } diff --git a/fleetctl/list_unit_files.go b/fleetctl/list_unit_files.go index 8599d0c22..4a74be94c 100644 --- a/fleetctl/list_unit_files.go +++ b/fleetctl/list_unit_files.go @@ -20,6 +20,9 @@ import ( "strconv" "strings" + "github.com/codegangsta/cli" + + "github.com/coreos/fleet/client" "github.com/coreos/fleet/machine" "github.com/coreos/fleet/schema" ) @@ -28,14 +31,14 @@ const ( defaultListUnitFilesFields = "unit,hash,dstate,state,target" ) -func mapTargetField(u schema.Unit, full bool) string { +func mapTargetField(u schema.Unit, full bool, cAPI client.API) string { if suToGlobal(u) { return "global" } if u.MachineID == "" { return "-" } - ms := cachedMachineState(u.MachineID) + ms := cachedMachineState(u.MachineID, cAPI) if ms == nil { ms = &machine.MachineState{ID: u.MachineID} } @@ -43,23 +46,30 @@ func mapTargetField(u schema.Unit, full bool) string { return machineFullLegend(*ms, full) } -var ( - listUnitFilesFieldsFlag string - cmdListUnitFiles = &Command{ +func NewListUnitFilesCommand() cli.Command { + return cli.Command{ Name: "list-unit-files", - Summary: "List the units that exist in the cluster.", - Usage: "[--fields]", - Description: `Lists all unit files that exist in the cluster (whether or not they are loaded onto a machine).`, - Run: runListUnitFiles, + Usage: "List the units that exist in the cluster.", + ArgsUsage: "[--fields]", + Description: "Lists all unit files that exist in the cluster (whether or not they are loaded onto a machine)", + Action: makeActionWrapper(runListUnitFiles), + Flags: []cli.Flag{ + cli.BoolFlag{Name: "full", Usage: "Do not ellipsize fields on output"}, + cli.BoolFlag{Name: "no-legend", Usage: "Do not print a legend (column headers)"}, + cli.StringFlag{Name: "fields", Value: defaultListUnitFilesFields, Usage: fmt.Sprintf("Columns to print for each Unit file. Valid fields are %q", strings.Join(unitToFieldKeys(listUnitFilesFields), ","))}, + }, } +} + +var ( listUnitFilesFields = map[string]unitToField{ - "unit": func(u schema.Unit, full bool) string { + "unit": func(u schema.Unit, full bool, cAPI client.API) string { return u.Name }, - "global": func(u schema.Unit, full bool) string { + "global": func(u schema.Unit, full bool, cAPI client.API) string { return strconv.FormatBool(suToGlobal(u)) }, - "dstate": func(u schema.Unit, full bool) string { + "dstate": func(u schema.Unit, full bool, cAPI client.API) string { if u.DesiredState == "" { return "-" } @@ -67,20 +77,20 @@ var ( }, "target": mapTargetField, "tmachine": mapTargetField, - "state": func(u schema.Unit, full bool) string { + "state": func(u schema.Unit, full bool, cAPI client.API) string { if suToGlobal(u) || u.CurrentState == "" { return "-" } return u.CurrentState }, - "hash": func(u schema.Unit, full bool) string { + "hash": func(u schema.Unit, full bool, cAPI client.API) string { uf := schema.MapSchemaUnitOptionsToUnitFile(u.Options) if !full { return uf.Hash().Short() } return uf.Hash().String() }, - "desc": func(u schema.Unit, full bool) string { + "desc": func(u schema.Unit, full bool, cAPI client.API) string { uf := schema.MapSchemaUnitOptionsToUnitFile(u.Options) d := uf.Description() if d == "" { @@ -91,15 +101,10 @@ var ( } ) -type unitToField func(u schema.Unit, full bool) string - -func init() { - cmdListUnitFiles.Flags.BoolVar(&sharedFlags.Full, "full", false, "Do not ellipsize fields on output") - cmdListUnitFiles.Flags.BoolVar(&sharedFlags.NoLegend, "no-legend", false, "Do not print a legend (column headers)") - cmdListUnitFiles.Flags.StringVar(&listUnitFilesFieldsFlag, "fields", defaultListUnitFilesFields, fmt.Sprintf("Columns to print for each Unit file. Valid fields are %q", strings.Join(unitToFieldKeys(listUnitFilesFields), ","))) -} +type unitToField func(u schema.Unit, full bool, cAPI client.API) string -func runListUnitFiles(args []string) (exit int) { +func runListUnitFiles(c *cli.Context, cAPI client.API) (exit int) { + listUnitFilesFieldsFlag := c.String("fields") if listUnitFilesFieldsFlag == "" { stderr("Must define output format") return 1 @@ -122,19 +127,20 @@ func runListUnitFiles(args []string) (exit int) { return 1 } - if !sharedFlags.NoLegend { + if !c.Bool("no-legend") { fmt.Fprintln(out, strings.ToUpper(strings.Join(cols, "\t"))) } for _, u := range units { var f []string - for _, c := range cols { - f = append(f, listUnitFilesFields[c](*u, sharedFlags.Full)) + for _, col := range cols { + f = append(f, listUnitFilesFields[col](*u, c.Bool("full"), cAPI)) } fmt.Fprintln(out, strings.Join(f, "\t")) } out.Flush() + return } diff --git a/fleetctl/list_unit_files_test.go b/fleetctl/list_unit_files_test.go index 07e44a7a0..e99782394 100644 --- a/fleetctl/list_unit_files_test.go +++ b/fleetctl/list_unit_files_test.go @@ -17,12 +17,20 @@ package main import ( "testing" + "github.com/coreos/fleet/client" "github.com/coreos/fleet/job" "github.com/coreos/fleet/machine" "github.com/coreos/fleet/schema" ) func TestListUnitFilesFieldsToStrings(t *testing.T) { + // c := createTestContext(t) + // stderr("Context: %v",c) + // cAPI := getClientAPI(c) + type fakeAPI struct { + client.API + } + cAPI := fakeAPI{} u := schema.Unit{ Name: "foo.service", Options: []*schema.UnitOption{}, @@ -35,11 +43,11 @@ func TestListUnitFilesFieldsToStrings(t *testing.T) { "tmachine": "-", "state": "-", } { - f := listUnitFilesFields[k](u, false) + f := listUnitFilesFields[k](u, false, cAPI) assertEqual(t, k, v, f) } - f := listUnitFilesFields["unit"](u, false) + f := listUnitFilesFields["unit"](u, false, cAPI) assertEqual(t, "unit", u.Name, f) u = schema.Unit{ @@ -49,12 +57,12 @@ func TestListUnitFilesFieldsToStrings(t *testing.T) { }, } - d := listUnitFilesFields["desc"](u, false) + d := listUnitFilesFields["desc"](u, false, cAPI) assertEqual(t, "desc", "some description", d) for _, state := range []job.JobState{job.JobStateLoaded, job.JobStateInactive, job.JobStateLaunched} { u.CurrentState = string(state) - f := listUnitFilesFields["state"](u, false) + f := listUnitFilesFields["state"](u, false, cAPI) assertEqual(t, "state", string(state), f) } @@ -62,7 +70,7 @@ func TestListUnitFilesFieldsToStrings(t *testing.T) { machineStates = map[string]*machine.MachineState{} u.MachineID = "some-id" - ms := listUnitFilesFields["tmachine"](u, true) + ms := listUnitFilesFields["tmachine"](u, true, cAPI) assertEqual(t, "machine", "some-id", ms) u.MachineID = "other-id" @@ -72,17 +80,21 @@ func TestListUnitFilesFieldsToStrings(t *testing.T) { PublicIP: "1.2.3.4", }, } - ms = listUnitFilesFields["tmachine"](u, true) + ms = listUnitFilesFields["tmachine"](u, true, cAPI) assertEqual(t, "machine", "other-id/1.2.3.4", ms) uh := "a0f275d46bc6ee0eca06be7c339913c07d99c0c7" - fuh := listUnitFilesFields["hash"](u, true) - suh := listUnitFilesFields["hash"](u, false) + fuh := listUnitFilesFields["hash"](u, true, cAPI) + suh := listUnitFilesFields["hash"](u, false, cAPI) assertEqual(t, "hash", uh, fuh) assertEqual(t, "hash", uh[:7], suh) } func TestMapTargetField(t *testing.T) { + type fakeAPI struct { + client.API + } + cAPI := fakeAPI{} // seeding the cache for the following test cases machineStates = map[string]*machine.MachineState{ "XXX": &machine.MachineState{ID: "XXX"}, @@ -117,7 +129,7 @@ func TestMapTargetField(t *testing.T) { for i, tt := range tests { // eliminate the "full" variable from test cases by hard-coding "true" below - got := mapTargetField(tt.unit, true) + got := mapTargetField(tt.unit, true, cAPI) if tt.want != got { t.Errorf("case %d: want=%q got=%q", i, tt.want, got) } diff --git a/fleetctl/list_units.go b/fleetctl/list_units.go index 28f682ac3..403c3fb3f 100644 --- a/fleetctl/list_units.go +++ b/fleetctl/list_units.go @@ -19,6 +19,9 @@ import ( "sort" "strings" + "github.com/codegangsta/cli" + + "github.com/coreos/fleet/client" "github.com/coreos/fleet/machine" "github.com/coreos/fleet/schema" ) @@ -27,61 +30,67 @@ const ( defaultListUnitsFields = "unit,machine,active,sub" ) -var ( - listUnitsFieldsFlag string - cmdListUnits = &Command{ - Name: "list-units", - Summary: "List the current state of units in the cluster", - Usage: "[--no-legend] [-l|--full] [--fields]", +func NewListUnitsCommand() cli.Command { + return cli.Command{ + Name: "list-units", + Usage: "List the current state of units in the cluster", + ArgsUsage: "[--no-legend] [-l|--full] [--fields]", Description: `Lists the state of all units in the cluster loaded onto a machine. For easily parsable output, you can remove the column headers: - fleetctl list-units --no-legend + fleetctl list-units --no-legend Output the list without ellipses: - fleetctl list-units --full + fleetctl list-units --full Or, choose the columns to display: - fleetctl list-units --fields=unit,machine`, - Run: runListUnits, + fleetctl list-units --fields=unit,machine`, + Action: makeActionWrapper(runListUnits), + Flags: []cli.Flag{ + cli.BoolFlag{Name: "full, l", Usage: "Do not ellipsize fields on output"}, + cli.BoolFlag{Name: "no-legend", Usage: "Do not print a legend (column headers)"}, + cli.StringFlag{Name: "fields", Value: defaultListUnitsFields, Usage: fmt.Sprintf("Columns to print for each Unit. Valid fields are %q", strings.Join(usToFieldKeys(listUnitsFields), ","))}, + }, } +} +var ( listUnitsFields = map[string]usToField{ - "unit": func(us *schema.UnitState, full bool) string { + "unit": func(us *schema.UnitState, full bool, cAPI client.API) string { if us == nil { return "-" } return us.Name }, - "load": func(us *schema.UnitState, full bool) string { + "load": func(us *schema.UnitState, full bool, cAPI client.API) string { if us == nil { return "-" } return us.SystemdLoadState }, - "active": func(us *schema.UnitState, full bool) string { + "active": func(us *schema.UnitState, full bool, cAPI client.API) string { if us == nil { return "-" } return us.SystemdActiveState }, - "sub": func(us *schema.UnitState, full bool) string { + "sub": func(us *schema.UnitState, full bool, cAPI client.API) string { if us == nil { return "-" } return us.SystemdSubState }, - "machine": func(us *schema.UnitState, full bool) string { + "machine": func(us *schema.UnitState, full bool, cAPI client.API) string { if us == nil || us.MachineID == "" { return "-" } - ms := cachedMachineState(us.MachineID) + ms := cachedMachineState(us.MachineID, cAPI) if ms == nil { ms = &machine.MachineState{ID: us.MachineID} } return machineFullLegend(*ms, full) }, - "hash": func(us *schema.UnitState, full bool) string { + "hash": func(us *schema.UnitState, full bool, cAPI client.API) string { if us == nil || us.Hash == "" { return "-" } @@ -93,16 +102,10 @@ Or, choose the columns to display: } ) -type usToField func(us *schema.UnitState, full bool) string - -func init() { - cmdListUnits.Flags.BoolVar(&sharedFlags.Full, "full", false, "Do not ellipsize fields on output") - cmdListUnits.Flags.BoolVar(&sharedFlags.Full, "l", false, "Shorthand for --full") - cmdListUnits.Flags.BoolVar(&sharedFlags.NoLegend, "no-legend", false, "Do not print a legend (column headers)") - cmdListUnits.Flags.StringVar(&listUnitsFieldsFlag, "fields", defaultListUnitsFields, fmt.Sprintf("Columns to print for each Unit. Valid fields are %q", strings.Join(usToFieldKeys(listUnitsFields), ","))) -} +type usToField func(us *schema.UnitState, full bool, cAPI client.API) string -func runListUnits(args []string) (exit int) { +func runListUnits(c *cli.Context, cAPI client.API) (exit int) { + listUnitsFieldsFlag := c.String("fields") if listUnitsFieldsFlag == "" { stderr("Must define output format") return 1 @@ -122,19 +125,20 @@ func runListUnits(args []string) (exit int) { return 1 } - if !sharedFlags.NoLegend { + if !c.Bool("no-legend") { fmt.Fprintln(out, strings.ToUpper(strings.Join(cols, "\t"))) } for _, us := range states { var f []string - for _, c := range cols { - f = append(f, listUnitsFields[c](us, sharedFlags.Full)) + for _, col := range cols { + f = append(f, listUnitsFields[col](us, c.Bool("full"), cAPI)) } fmt.Fprintln(out, strings.Join(f, "\t")) } out.Flush() + return } diff --git a/fleetctl/list_units_test.go b/fleetctl/list_units_test.go index 25e1411bf..99de255aa 100644 --- a/fleetctl/list_units_test.go +++ b/fleetctl/list_units_test.go @@ -17,6 +17,7 @@ package main import ( "testing" + "github.com/coreos/fleet/client" "github.com/coreos/fleet/job" "github.com/coreos/fleet/machine" "github.com/coreos/fleet/registry" @@ -36,9 +37,14 @@ func assertEqual(t *testing.T, name string, want, got interface{}) { } func TestListUnitsFieldsToStrings(t *testing.T) { + type fakeAPI struct { + client.API + } + cAPI := fakeAPI{} + // nil UnitState shouldn't happen, but just in case for _, tt := range []string{"unit", "load", "active", "sub", "machine", "hash"} { - f := listUnitsFields[tt](nil, false) + f := listUnitsFields[tt](nil, false, cAPI) assertEqual(t, tt, "-", f) } @@ -57,12 +63,12 @@ func TestListUnitsFieldsToStrings(t *testing.T) { "machine": "-", "unit": "sleep", } { - got := listUnitsFields[k](us, false) + got := listUnitsFields[k](us, false, cAPI) assertEqual(t, k, want, got) } us.MachineID = "some-id" - ms := listUnitsFields["machine"](us, true) + ms := listUnitsFields["machine"](us, true, cAPI) assertEqual(t, "machine", "some-id", ms) us.MachineID = "other-id" @@ -72,13 +78,13 @@ func TestListUnitsFieldsToStrings(t *testing.T) { PublicIP: "1.2.3.4", }, } - ms = listUnitsFields["machine"](us, true) + ms = listUnitsFields["machine"](us, true, cAPI) assertEqual(t, "machine", "other-id/1.2.3.4", ms) uh := "a0f275d46bc6ee0eca06be7c339913c07d99c0c7" us.Hash = uh - fuh := listUnitsFields["hash"](us, true) - suh := listUnitsFields["hash"](us, false) + fuh := listUnitsFields["hash"](us, true, cAPI) + suh := listUnitsFields["hash"](us, false, cAPI) assertEqual(t, "hash", uh, fuh) assertEqual(t, "hash", uh[:7], suh) } diff --git a/fleetctl/load.go b/fleetctl/load.go index 94b78c489..a72df158d 100644 --- a/fleetctl/load.go +++ b/fleetctl/load.go @@ -17,14 +17,17 @@ package main import ( "os" + "github.com/codegangsta/cli" + + "github.com/coreos/fleet/client" "github.com/coreos/fleet/job" ) -var ( - cmdLoadUnits = &Command{ - Name: "load", - Summary: "Schedule one or more units in the cluster, first submitting them if necessary.", - Usage: "[--no-block|--block-attempts=N] UNIT...", +func NewLoadUnitsCommand() cli.Command { + return cli.Command{ + Name: "load", + Usage: "Schedule one or more units in the cluster, first submitting them if necessary.", + ArgsUsage: "[--no-block|--block-attempts=N] UNIT...", Description: `Load one or many units in the cluster into systemd, but do not start. Select units to load by glob matching for units in the current working directory @@ -35,29 +38,29 @@ which means fleetctl will block until it detects that the unit(s) have transitioned to a loaded state. This behaviour can be configured with the respective --block-attempts and --no-block options. Load operations on global units are always non-blocking.`, - Run: runLoadUnits, + Action: makeActionWrapper(runLoadUnits), + Flags: []cli.Flag{ + cli.BoolFlag{Name: "sign", Usage: "DEPRECATED - this option cannot be used"}, + cli.IntFlag{Name: "block-attempts", Value: 0, Usage: "ait until the jobs are loaded, performing up to N attempts before giving up. A value of 0 indicates no limit. Does not apply to global units."}, + cli.BoolFlag{Name: "no-block", Usage: "Do not wait until the jobs have been loaded before exiting. Always the case for global units."}, + cli.BoolFlag{Name: "replace", Usage: "Replace the old scheduled units in the cluster with new versions."}, + }, } -) - -func init() { - cmdLoadUnits.Flags.BoolVar(&sharedFlags.Sign, "sign", false, "DEPRECATED - this option cannot be used") - cmdLoadUnits.Flags.IntVar(&sharedFlags.BlockAttempts, "block-attempts", 0, "Wait until the jobs are loaded, performing up to N attempts before giving up. A value of 0 indicates no limit. Does not apply to global units.") - cmdLoadUnits.Flags.BoolVar(&sharedFlags.NoBlock, "no-block", false, "Do not wait until the jobs have been loaded before exiting. Always the case for global units.") - cmdLoadUnits.Flags.BoolVar(&sharedFlags.Replace, "replace", false, "Replace the old scheduled units in the cluster with new versions.") } -func runLoadUnits(args []string) (exit int) { +func runLoadUnits(c *cli.Context, cAPI client.API) (exit int) { + args := c.Args() if len(args) == 0 { stderr("No units given") return 0 } - if err := lazyCreateUnits(args); err != nil { + if err := lazyCreateUnits(c, cAPI); err != nil { stderr("Error creating units: %v", err) return 1 } - triggered, err := lazyLoadUnits(args) + triggered, err := lazyLoadUnits(args, cAPI) if err != nil { stderr("Error loading units: %v", err) return 1 @@ -72,7 +75,7 @@ func runLoadUnits(args []string) (exit int) { } } - exit = tryWaitForUnitStates(loading, "load", job.JobStateLoaded, getBlockAttempts(), os.Stdout) + exit = tryWaitForUnitStates(loading, "load", job.JobStateLoaded, getBlockAttempts(c), os.Stdout, cAPI) return } diff --git a/fleetctl/load_test.go b/fleetctl/load_test.go index 51b5f2739..b27337a10 100644 --- a/fleetctl/load_test.go +++ b/fleetctl/load_test.go @@ -19,6 +19,9 @@ import ( "sync" "testing" + "github.com/codegangsta/cli" + + "github.com/coreos/fleet/client" "github.com/coreos/fleet/job" "github.com/coreos/fleet/schema" ) @@ -35,14 +38,14 @@ func checkLoadUnitState(unit schema.Unit, loadRet int, errchan chan error) { } } -func doLoadUnits(r commandTestResults, errchan chan error) { - exit := runLoadUnits(r.units) +func doLoadUnits(t *testing.T, r commandTestResults, errchan chan error, cAPI client.API, c *cli.Context) { + exit := runLoadUnits(c, cAPI) if exit != r.expectedExit { errchan <- fmt.Errorf("%s: expected exit code %d but received %d", r.description, r.expectedExit, exit) return } - real_units, err := findUnits(r.units) + real_units, err := findUnits(r.units, cAPI) if err != nil { errchan <- err return @@ -55,10 +58,6 @@ func doLoadUnits(r commandTestResults, errchan chan error) { func TestRunLoadUnits(t *testing.T) { unitPrefix := "load" - oldNoBlock := sharedFlags.NoBlock - defer func() { - sharedFlags.NoBlock = oldNoBlock - }() results := []commandTestResults{ { @@ -83,21 +82,21 @@ func TestRunLoadUnits(t *testing.T) { }, } - sharedFlags.NoBlock = true for _, r := range results { var wg sync.WaitGroup errchan := make(chan error) - cAPI = newFakeRegistryForCommands(unitPrefix, len(r.units), false) + cAPI := newFakeRegistryForCommands(unitPrefix, len(r.units), false) + c := createTestContext(t, append([]string{"load", "--no-block"}, r.units...)...) wg.Add(2) go func() { defer wg.Done() - doLoadUnits(r, errchan) + doLoadUnits(t, r, errchan, cAPI, c) }() go func() { defer wg.Done() - doLoadUnits(r, errchan) + doLoadUnits(t, r, errchan, cAPI, c) }() go func() { diff --git a/fleetctl/ssh.go b/fleetctl/ssh.go index 54a2dc626..dc0cd56dd 100644 --- a/fleetctl/ssh.go +++ b/fleetctl/ssh.go @@ -24,55 +24,53 @@ import ( "strings" "syscall" + "github.com/codegangsta/cli" + + "github.com/coreos/fleet/client" "github.com/coreos/fleet/machine" "github.com/coreos/fleet/pkg" "github.com/coreos/fleet/ssh" ) -var ( - flagMachine string - flagUnit string - flagSSHAgentForwarding bool - cmdSSH = &Command{ - Name: "ssh", - Summary: "Open interactive shell on a machine in the cluster", - Usage: "[-A|--forward-agent] [--ssh-port=N] [--machine|--unit] {MACHINE|UNIT}", - Description: `Open an interactive shell on a specific machine in the cluster or on the machine -where the specified unit is located. +func NewSSHCommend() cli.Command { + return cli.Command{ + Name: "ssh", + Usage: "Open interactive shell on a machine in the cluster", + ArgsUsage: "[-A|--forward-agent] [--ssh-port=N] [--machine|--unit] {MACHINE|UNIT}", + Description: `Open an interactive shell on a specific machine in the cluster or on the machine where the specified unit is located. fleetctl tries to detect whether your first argument is a machine or a unit. To skip this check use the --machine or --unit flags. Open a shell on a machine: - fleetctl ssh 2444264c-eac2-4eff-a490-32d5e5e4af24 + fleetctl ssh 2444264c-eac2-4eff-a490-32d5e5e4af24 Open a shell from your laptop, to the machine running a specific unit, using a cluster member as a bastion host: - fleetctl --tunnel 10.10.10.10 ssh foo.service + fleetctl --tunnel 10.10.10.10 ssh foo.service Open a shell on a machine and forward the authentication agent connection: - fleetctl ssh --forward-agent 2444264c-eac2-4eff-a490-32d5e5e4af24 + fleetctl ssh --forward-agent 2444264c-eac2-4eff-a490-32d5e5e4af24 Tip: Create an alias for --tunnel. - - Add "alias fleetctl=fleetctl --tunnel 10.10.10.10" to your bash profile. - - Now you can run all fleet commands locally. + - Add "alias fleetctl=fleetctl --tunnel 10.10.10.10" to your bash profile. + - Now you can run all fleet commands locally. This command does not work with global units.`, - Run: runSSH, + Action: makeActionWrapper(runSSH), + Flags: []cli.Flag{ + cli.StringFlag{Name: "machine", Value: "", Usage: "Open SSH connection to a specific machine."}, + cli.StringFlag{Name: "unit", Value: "", Usage: "Open SSH connection to machine running provided unit."}, + cli.BoolFlag{Name: "forward-agent, A", Usage: "forward local ssh-agent to target machine."}, + cli.IntFlag{Name: "ssh-port", Value: 22, Usage: "Connect to remote hosts over SSH using this TCP port."}, + }, } -) - -func init() { - cmdSSH.Flags.StringVar(&flagMachine, "machine", "", "Open SSH connection to a specific machine.") - cmdSSH.Flags.StringVar(&flagUnit, "unit", "", "Open SSH connection to machine running provided unit.") - cmdSSH.Flags.BoolVar(&flagSSHAgentForwarding, "forward-agent", false, "Forward local ssh-agent to target machine.") - cmdSSH.Flags.BoolVar(&flagSSHAgentForwarding, "A", false, "Shorthand for --forward-agent") - cmdSSH.Flags.IntVar(&sharedFlags.SSHPort, "ssh-port", 22, "Connect to remote hosts over SSH using this TCP port.") } -func runSSH(args []string) (exit int) { - if flagUnit != "" && flagMachine != "" { +func runSSH(c *cli.Context, cAPI client.API) (exit int) { + args := c.Args() + if c.String("unit") != "" && c.String("machine") != "" { stderr("Both machine and unit flags provided, please specify only one.") return 1 } @@ -81,12 +79,12 @@ func runSSH(args []string) (exit int) { var addr string switch { - case flagMachine != "": - addr, _, err = findAddressInMachineList(flagMachine) - case flagUnit != "": - addr, _, err = findAddressInRunningUnits(flagUnit) + case c.String("machine") != "": + addr, _, err = findAddressInMachineList(c.String("machine"), cAPI) + case c.String("unit") != "": + addr, _, err = findAddressInRunningUnits(c.String("unit"), cAPI) default: - addr, err = globalMachineLookup(args) + addr, err = globalMachineLookup(args, cAPI) // trim machine/unit name from args if len(args) > 0 { args = args[1:] @@ -103,16 +101,16 @@ func runSSH(args []string) (exit int) { return 1 } - addr = findSSHPort(addr) + addr = findSSHPort(addr, c) args = pkg.TrimToDashes(args) var sshClient *ssh.SSHForwardingClient - timeout := getSSHTimeoutFlag() - if tun := getTunnelFlag(); tun != "" { - sshClient, err = ssh.NewTunnelledSSHClient(globalFlags.SSHUserName, tun, addr, getChecker(), flagSSHAgentForwarding, timeout) + timeout := getSSHTimeoutFlag(c) + if tun := getTunnelFlag(c); tun != "" { + sshClient, err = ssh.NewTunnelledSSHClient(c.GlobalString("ssh-username"), tun, addr, getChecker(c), c.Bool("forward-agent"), timeout) } else { - sshClient, err = ssh.NewSSHClient(globalFlags.SSHUserName, addr, getChecker(), flagSSHAgentForwarding, timeout) + sshClient, err = ssh.NewSSHClient(c.GlobalString("ssh-username"), addr, getChecker(c), c.Bool("forward-agent"), timeout) } if err != nil { stderr("Failed building SSH client: %v", err) @@ -130,29 +128,30 @@ func runSSH(args []string) (exit int) { } else { if err := ssh.Shell(sshClient); err != nil { stderr("Failed opening shell over SSH: %v", err) - exit = 1 + return 1 } } + return } -func findSSHPort(addr string) string { - if sharedFlags.SSHPort != 22 && !strings.Contains(addr, ":") { - return net.JoinHostPort(addr, strconv.Itoa(sharedFlags.SSHPort)) +func findSSHPort(addr string, c *cli.Context) string { + if c.Int("ssh-port") != 22 && !strings.Contains(addr, ":") { + return net.JoinHostPort(addr, strconv.Itoa(c.Int("ssh-port"))) } else { return addr } } -func globalMachineLookup(args []string) (string, error) { +func globalMachineLookup(args []string, cAPI client.API) (string, error) { if len(args) == 0 { return "", errors.New("one machine or unit must be provided") } lookup := args[0] - machineAddr, machineOk, _ := findAddressInMachineList(lookup) - unitAddr, unitOk, _ := findAddressInRunningUnits(lookup) + machineAddr, machineOk, _ := findAddressInMachineList(lookup, cAPI) + unitAddr, unitOk, _ := findAddressInRunningUnits(lookup, cAPI) switch { case machineOk && unitOk: @@ -166,7 +165,7 @@ func globalMachineLookup(args []string) (string, error) { return "", fmt.Errorf("could not find matching unit or machine") } -func findAddressInMachineList(lookup string) (string, bool, error) { +func findAddressInMachineList(lookup string, cAPI client.API) (string, bool, error) { states, err := cAPI.Machines() if err != nil { return "", false, err @@ -193,7 +192,7 @@ func findAddressInMachineList(lookup string) (string, bool, error) { return match.PublicIP, true, nil } -func findAddressInRunningUnits(name string) (string, bool, error) { +func findAddressInRunningUnits(name string, cAPI client.API) (string, bool, error) { name = unitNameMangle(name) u, err := cAPI.Unit(name) if err != nil { @@ -204,7 +203,7 @@ func findAddressInRunningUnits(name string) (string, bool, error) { return "", false, fmt.Errorf("global units unsupported") } - m := cachedMachineState(u.MachineID) + m := cachedMachineState(u.MachineID, cAPI) if m != nil && m.PublicIP != "" { return m.PublicIP, true, nil } @@ -214,7 +213,7 @@ func findAddressInRunningUnits(name string) (string, bool, error) { // runCommand will attempt to run a command on a given machine. It will attempt // to SSH to the machine if it is identified as being remote. -func runCommand(machID string, cmd string, args ...string) (retcode int) { +func runCommand(c *cli.Context, cAPI client.API, machID string, cmd string, args ...string) (retcode int) { var err error if machine.IsLocalMachineID(machID) { err, retcode = runLocalCommand(cmd, args...) @@ -222,12 +221,12 @@ func runCommand(machID string, cmd string, args ...string) (retcode int) { stderr("Error running local command: %v", err) } } else { - ms, err := machineState(machID) + ms, err := machineState(machID, cAPI) if err != nil || ms == nil { stderr("Error getting machine IP: %v", err) } else { - addr := findSSHPort(ms.PublicIP) - err, retcode = runRemoteCommand(addr, cmd, args...) + addr := findSSHPort(ms.PublicIP, c) + err, retcode = runRemoteCommand(c, addr, cmd, args...) if err != nil { stderr("Error running remote command: %v", err) } @@ -258,13 +257,13 @@ func runLocalCommand(cmd string, args ...string) (error, int) { // runRemoteCommand runs the given command over SSH on the given IP, and returns // any error encountered and the exit status of the command -func runRemoteCommand(addr string, cmd string, args ...string) (err error, exit int) { +func runRemoteCommand(c *cli.Context, addr string, cmd string, args ...string) (err error, exit int) { var sshClient *ssh.SSHForwardingClient - timeout := getSSHTimeoutFlag() - if tun := getTunnelFlag(); tun != "" { - sshClient, err = ssh.NewTunnelledSSHClient(globalFlags.SSHUserName, tun, addr, getChecker(), false, timeout) + timeout := getSSHTimeoutFlag(c) + if tun := getTunnelFlag(c); tun != "" { + sshClient, err = ssh.NewTunnelledSSHClient(c.GlobalString("ssh-username"), tun, addr, getChecker(c), false, timeout) } else { - sshClient, err = ssh.NewSSHClient(globalFlags.SSHUserName, addr, getChecker(), false, timeout) + sshClient, err = ssh.NewSSHClient(c.GlobalString("ssh-username"), addr, getChecker(c), false, timeout) } if err != nil { return err, -1 diff --git a/fleetctl/ssh_test.go b/fleetctl/ssh_test.go index 0e5845b18..980993ac2 100644 --- a/fleetctl/ssh_test.go +++ b/fleetctl/ssh_test.go @@ -80,54 +80,54 @@ func newFakeRegistryForSsh() client.API { } func TestSshUnknownMachine(t *testing.T) { - cAPI = newFakeRegistryForSsh() + cAPI := newFakeRegistryForSsh() - _, ok, _ := findAddressInMachineList("asdf") + _, ok, _ := findAddressInMachineList("asdf", cAPI) if ok { t.Error("Expected to not find any machine with the machine ID `asdf`") } } func TestSshFindMachine(t *testing.T) { - cAPI = newFakeRegistryForSsh() + cAPI := newFakeRegistryForSsh() - ip, _, _ := findAddressInMachineList("c31e44e1-f858-436e-933e-59c642517860") + ip, _, _ := findAddressInMachineList("c31e44e1-f858-436e-933e-59c642517860", cAPI) if ip != "1.2.3.4" { t.Errorf("Expected to return the host 1.2.3.4, but it was %s", ip) } } func TestSshFindMachineByUnknownUnitName(t *testing.T) { - cAPI = newFakeRegistryForSsh() + cAPI := newFakeRegistryForSsh() - _, ok, _ := findAddressInRunningUnits("asdf") + _, ok, _ := findAddressInRunningUnits("asdf", cAPI) if ok { t.Error("Expected to not find any machine with the unit name `asdf`") } } func TestSshFindMachineByUnitName(t *testing.T) { - cAPI = newFakeRegistryForSsh() + cAPI := newFakeRegistryForSsh() - ip, _, _ := findAddressInRunningUnits("j1") + ip, _, _ := findAddressInRunningUnits("j1", cAPI) if ip != "1.2.3.4" { t.Errorf("Expected to return the host 1.2.3.4, but it was %s", ip) } } func TestGlobalLookupByUnknownArgument(t *testing.T) { - cAPI = newFakeRegistryForSsh() + cAPI := newFakeRegistryForSsh() - _, err := globalMachineLookup([]string{"asdf"}) + _, err := globalMachineLookup([]string{"asdf"}, cAPI) if err == nil { t.Fatal("Expected to receive error, got nil") } } func TestGlobalLookupByMachineID(t *testing.T) { - cAPI = newFakeRegistryForSsh() + cAPI := newFakeRegistryForSsh() - ip, err := globalMachineLookup([]string{"c31e44e1-f858-436e-933e-59c642517860"}) + ip, err := globalMachineLookup([]string{"c31e44e1-f858-436e-933e-59c642517860"}, cAPI) if err != nil { t.Fatal("Expected to not find any error") } @@ -138,9 +138,9 @@ func TestGlobalLookupByMachineID(t *testing.T) { } func TestGlobalLookupByUnitName(t *testing.T) { - cAPI = newFakeRegistryForSsh() + cAPI := newFakeRegistryForSsh() - ip, err := globalMachineLookup([]string{"j1"}) + ip, err := globalMachineLookup([]string{"j1"}, cAPI) if err != nil { t.Fatal("Expected to not find any error") } @@ -151,9 +151,9 @@ func TestGlobalLookupByUnitName(t *testing.T) { } func TestGlobalLookupWithAmbiguousArgument(t *testing.T) { - cAPI = newFakeRegistryForSsh() + cAPI := newFakeRegistryForSsh() - _, err := globalMachineLookup([]string{"hello.service"}) + _, err := globalMachineLookup([]string{"hello.service"}, cAPI) if err == nil { t.Fatal("Expected to find an error with an ambiguous argument") } diff --git a/fleetctl/start.go b/fleetctl/start.go index c053f1780..790542ce9 100644 --- a/fleetctl/start.go +++ b/fleetctl/start.go @@ -17,17 +17,18 @@ package main import ( "os" + "github.com/codegangsta/cli" + + "github.com/coreos/fleet/client" "github.com/coreos/fleet/job" ) -var ( - cmdStartUnit = &Command{ - Name: "start", - Summary: "Instruct systemd to start one or more units in the cluster, first submitting and loading if necessary.", - Usage: "[--no-block|--block-attempts=N] UNIT...", - Description: `Start one or many units on the cluster. Select units to start by glob matching -for units in the current working directory or matching names of previously -submitted units. +func NewStartCommand() cli.Command { + return cli.Command{ + Name: "start", + Usage: "Instruct systemd to start one or more units in the cluster, first submitting and loading if necessary.", + ArgsUsage: "[--no-block|--block-attempts=N] UNIT...", + Description: `Start one or many units on the cluster. Select units to start by glob matching for units in the current working directory or matching names of previously submitted units. For units which are not global, start operations are performed synchronously, which means fleetctl will block until it detects that the unit(s) have @@ -36,36 +37,36 @@ respective --block-attempts and --no-block options. Start operations on global units are always non-blocking. Start a single unit: - fleetctl start foo.service + fleetctl start foo.service Start an entire directory of units with glob matching: - fleetctl start myservice/* + fleetctl start myservice/* You may filter suitable hosts based on metadata provided by the machine. Machine metadata is located in the fleet configuration file.`, - Run: runStartUnit, + Action: makeActionWrapper(runStartUnit), + Flags: []cli.Flag{ + cli.BoolFlag{Name: "sign", Usage: "DEPRECATED - this option cannot be used"}, + cli.IntFlag{Name: "block-attempts", Value: 0, Usage: "Wait until the units are launched, performing up to N attempts before giving up. A value of 0 indicates no limit. Does not apply to global units."}, + cli.BoolFlag{Name: "no-block", Usage: "Do not wait until the units have launched before exiting. Always the case for global units."}, + cli.BoolFlag{Name: "replace", Usage: "Replace the already started units in the cluster with new versions."}, + }, } -) - -func init() { - cmdStartUnit.Flags.BoolVar(&sharedFlags.Sign, "sign", false, "DEPRECATED - this option cannot be used") - cmdStartUnit.Flags.IntVar(&sharedFlags.BlockAttempts, "block-attempts", 0, "Wait until the units are launched, performing up to N attempts before giving up. A value of 0 indicates no limit. Does not apply to global units.") - cmdStartUnit.Flags.BoolVar(&sharedFlags.NoBlock, "no-block", false, "Do not wait until the units have launched before exiting. Always the case for global units.") - cmdStartUnit.Flags.BoolVar(&sharedFlags.Replace, "replace", false, "Replace the already started units in the cluster with new versions.") } -func runStartUnit(args []string) (exit int) { +func runStartUnit(c *cli.Context, cAPI client.API) (exit int) { + args := c.Args() if len(args) == 0 { stderr("No units given") return 0 } - if err := lazyCreateUnits(args); err != nil { + if err := lazyCreateUnits(c, cAPI); err != nil { stderr("Error creating units: %v", err) return 1 } - triggered, err := lazyStartUnits(args) + triggered, err := lazyStartUnits(args, cAPI) if err != nil { stderr("Error starting units: %v", err) return 1 @@ -80,7 +81,6 @@ func runStartUnit(args []string) (exit int) { } } - exit = tryWaitForUnitStates(starting, "start", job.JobStateLaunched, getBlockAttempts(), os.Stdout) - + exit = tryWaitForUnitStates(starting, "start", job.JobStateLaunched, getBlockAttempts(c), os.Stdout, cAPI) return } diff --git a/fleetctl/start_test.go b/fleetctl/start_test.go index 8a43b937f..98cdb64e0 100644 --- a/fleetctl/start_test.go +++ b/fleetctl/start_test.go @@ -19,6 +19,7 @@ import ( "sync" "testing" + "github.com/coreos/fleet/client" "github.com/coreos/fleet/job" "github.com/coreos/fleet/schema" ) @@ -35,14 +36,15 @@ func checkStartUnitState(unit schema.Unit, startRet int, errchan chan error) { } } -func doStartUnits(r commandTestResults, errchan chan error) { - exit := runStartUnit(r.units) +func doStartUnits(t *testing.T, r commandTestResults, errchan chan error, cAPI client.API) { + c := createTestContext(t, append([]string{"start", "--no-block"}, r.units...)...) + exit := runStartUnit(c, cAPI) if exit != r.expectedExit { errchan <- fmt.Errorf("%s: expected exit code %d but received %d", r.description, r.expectedExit, exit) return } - real_units, err := findUnits(r.units) + real_units, err := findUnits(r.units, cAPI) if err != nil { errchan <- err return @@ -55,7 +57,6 @@ func doStartUnits(r commandTestResults, errchan chan error) { func runStartUnits(t *testing.T, unitPrefix string, results []commandTestResults, template bool) { unitsCount := 0 - sharedFlags.NoBlock = true for _, r := range results { var wg sync.WaitGroup errchan := make(chan error) @@ -64,12 +65,11 @@ func runStartUnits(t *testing.T, unitPrefix string, results []commandTestResults unitsCount = len(r.units) } - cAPI = newFakeRegistryForCommands(unitPrefix, unitsCount, template) - + cAPI := newFakeRegistryForCommands(unitPrefix, unitsCount, template) wg.Add(1) go func() { defer wg.Done() - doStartUnits(r, errchan) + doStartUnits(t, r, errchan, cAPI) }() go func() { @@ -85,10 +85,6 @@ func runStartUnits(t *testing.T, unitPrefix string, results []commandTestResults func TestRunStartUnits(t *testing.T) { unitPrefix := "start" - oldNoBlock := sharedFlags.NoBlock - defer func() { - sharedFlags.NoBlock = oldNoBlock - }() results := []commandTestResults{ { @@ -136,7 +132,6 @@ func TestRunStartUnits(t *testing.T) { }, } - sharedFlags.NoBlock = true runStartUnits(t, unitPrefix, results, false) runStartUnits(t, unitPrefix, templateResults, true) } diff --git a/fleetctl/status.go b/fleetctl/status.go index cfbb34470..273135aae 100644 --- a/fleetctl/status.go +++ b/fleetctl/status.go @@ -17,32 +17,37 @@ package main import ( "fmt" + "github.com/codegangsta/cli" + + "github.com/coreos/fleet/client" "github.com/coreos/fleet/job" ) -var cmdStatusUnits = &Command{ - Name: "status", - Summary: "Output the status of one or more units in the cluster", - Usage: "[--ssh-port=N] UNIT...", - Description: `Output the status of one or more units currently running in the cluster. +func NewStatusCommand() cli.Command { + return cli.Command{ + Name: "status", + Usage: "Output the status of one or more units in the cluster", + ArgsUsage: "[--ssh-port=N] UNIT...", + Description: `Output the status of one or more units currently running in the cluster. Supports glob matching of units in the current working directory or matches previously started units. Show status of a single unit: - fleetctl status foo.service + fleetctl status foo.service Show status of an entire directory with glob matching: fleetctl status myservice/* This command does not work with global units.`, - Run: runStatusUnits, -} - -func init() { - cmdStatusUnits.Flags.IntVar(&sharedFlags.SSHPort, "ssh-port", 22, "Connect to remote hosts over SSH using this TCP port.") + Action: makeActionWrapper(runStatusUnits), + Flags: []cli.Flag{ + cli.IntFlag{Name: "ssh-port", Value: 22, Usage: "Connect to remote hosts over SSH using this TCP port."}, + }, + } } -func runStatusUnits(args []string) (exit int) { +func runStatusUnits(c *cli.Context, cAPI client.API) (exit int) { + args := c.Args() for i, arg := range args { name := unitNameMangle(arg) unit, err := cAPI.Unit(name) @@ -67,7 +72,7 @@ func runStatusUnits(args []string) (exit int) { fmt.Printf("\n") } - if exit = runCommand(unit.MachineID, "systemctl", "status", "-l", unit.Name); exit != 0 { + if exit = runCommand(c, cAPI, unit.MachineID, "systemctl", "status", "-l", unit.Name); exit != 0 { break } } diff --git a/fleetctl/stop.go b/fleetctl/stop.go index ab3c27d75..f09864bd9 100644 --- a/fleetctl/stop.go +++ b/fleetctl/stop.go @@ -17,16 +17,19 @@ package main import ( "os" + "github.com/codegangsta/cli" + + "github.com/coreos/fleet/client" "github.com/coreos/fleet/job" "github.com/coreos/fleet/log" ) -var cmdStopUnit = &Command{ - Name: "stop", - Summary: "Instruct systemd to stop one or more units in the cluster.", - Usage: "[--no-block|--block-attempts=N] UNIT...", - Description: `Stop one or more units from running in the cluster, but allow them to be -started again in the future. +func NewStopUnitCommand() cli.Command { + return cli.Command{ + Name: "stop", + Usage: "Instruct systemd to stop one or more units in the cluster.", + ArgsUsage: "[--no-block|--block-attempts=N] UNIT...", + Description: `Stop one or more units from running in the cluster, but allow them to be started again in the future. Instructs systemd on the host machine to stop the unit, deferring to systemd completely for any custom stop directives (i.e. ExecStop option in the unit @@ -39,25 +42,26 @@ respective --block-attempts and --no-block options. Stop operations on global units are always non-blocking. Stop a single unit: - fleetctl stop foo.service + fleetctl stop foo.service Stop an entire directory of units with glob matching, without waiting: - fleetctl --no-block stop myservice/*`, - Run: runStopUnit, -} - -func init() { - cmdStopUnit.Flags.IntVar(&sharedFlags.BlockAttempts, "block-attempts", 0, "Wait until the units are stopped, performing up to N attempts before giving up. A value of 0 indicates no limit. Does not apply to global units.") - cmdStopUnit.Flags.BoolVar(&sharedFlags.NoBlock, "no-block", false, "Do not wait until the units have stopped before exiting. Always the case for global units.") + fleetctl --no-block stop myservice/*`, + Action: makeActionWrapper(runStopUnit), + Flags: []cli.Flag{ + cli.IntFlag{Name: "block-attempts", Value: 22, Usage: "Wait until the units are stopped, performing up to N attempts before giving up. A value of 0 indicates no limit. Does not apply to global units."}, + cli.BoolFlag{Name: "no-block", Usage: "Do not wait until the units have stopped before exiting. Always the case for global units."}, + }, + } } -func runStopUnit(args []string) (exit int) { +func runStopUnit(c *cli.Context, cAPI client.API) (exit int) { + args := c.Args() if len(args) == 0 { stderr("No units given") return 0 } - units, err := findUnits(args) + units, err := findUnits(args, cAPI) if err != nil { stderr("%v", err) return 1 @@ -84,7 +88,7 @@ func runStopUnit(args []string) (exit int) { } } - exit = tryWaitForUnitStates(stopping, "stop", job.JobStateLoaded, getBlockAttempts(), os.Stdout) + exit = tryWaitForUnitStates(stopping, "stop", job.JobStateLoaded, getBlockAttempts(c), os.Stdout, cAPI) if exit == 0 { stderr("Successfully stopped units %v.", stopping) } else { diff --git a/fleetctl/stop_test.go b/fleetctl/stop_test.go index 708bf42ae..df047140b 100644 --- a/fleetctl/stop_test.go +++ b/fleetctl/stop_test.go @@ -19,17 +19,20 @@ import ( "sync" "testing" + "github.com/codegangsta/cli" + + "github.com/coreos/fleet/client" "github.com/coreos/fleet/job" ) -func doStopUnits(r commandTestResults, errchan chan error) { - exit := runStopUnit(r.units) +func doStopUnits(t *testing.T, r commandTestResults, errchan chan error, cAPI client.API, c *cli.Context) { + exit := runStopUnit(c, cAPI) if exit != r.expectedExit { errchan <- fmt.Errorf("%s: expected exit code %d but received %d", r.description, r.expectedExit, exit) return } - real_units, err := findUnits(r.units) + real_units, err := findUnits(r.units, cAPI) if err != nil { errchan <- err return @@ -45,10 +48,6 @@ func doStopUnits(r commandTestResults, errchan chan error) { func TestRunStopUnits(t *testing.T) { unitPrefix := "stop" - oldNoBlock := sharedFlags.NoBlock - defer func() { - sharedFlags.NoBlock = oldNoBlock - }() results := []commandTestResults{ { @@ -73,21 +72,22 @@ func TestRunStopUnits(t *testing.T) { }, } - sharedFlags.NoBlock = true for _, r := range results { var wg sync.WaitGroup errchan := make(chan error) - cAPI = newFakeRegistryForCommands(unitPrefix, len(r.units), false) + cAPI := newFakeRegistryForCommands(unitPrefix, len(r.units), false) + + c := createTestContext(t, append([]string{"stop", "--no-block"}, r.units...)...) wg.Add(2) go func() { defer wg.Done() - doStopUnits(r, errchan) + doStopUnits(t, r, errchan, cAPI, c) }() go func() { defer wg.Done() - doStopUnits(r, errchan) + doStopUnits(t, r, errchan, cAPI, c) }() go func() { diff --git a/fleetctl/submit.go b/fleetctl/submit.go index 9b563aecf..333123bfb 100644 --- a/fleetctl/submit.go +++ b/fleetctl/submit.go @@ -14,37 +14,45 @@ package main -var cmdSubmitUnit = &Command{ - Name: "submit", - Summary: "Upload one or more units to the cluster without starting them", - Usage: "UNIT...", - Description: `Upload one or more units to the cluster without starting them. Useful -for validating units before they are started. +import ( + "github.com/codegangsta/cli" + + "github.com/coreos/fleet/client" +) + +func NewSubmitUnitCommand() cli.Command { + return cli.Command{ + Name: "submit", + Usage: "Upload one or more units to the cluster without starting them", + ArgsUsage: "UNIT...", + Description: `Upload one or more units to the cluster without starting them. Useful for validating units before they are started. This operation is idempotent; if a named unit already exists in the cluster, it will not be resubmitted. Submit a single unit: - fleetctl submit foo.service + fleetctl submit foo.service Submit a directory of units with glob matching: - fleetctl submit myservice/*`, - Run: runSubmitUnits, -} - -func init() { - cmdSubmitUnit.Flags.BoolVar(&sharedFlags.Sign, "sign", false, "DEPRECATED - this option cannot be used") - cmdSubmitUnit.Flags.BoolVar(&sharedFlags.Replace, "replace", false, "Replace the old submitted units in the cluster with new versions.") + fleetctl submit myservice/*`, + Action: makeActionWrapper(runSubmitUnits), + Flags: []cli.Flag{ + cli.BoolFlag{Name: "sign", Usage: "DEPRECATED - this option cannot be used"}, + cli.BoolFlag{Name: "replace", Usage: "Replace the old submitted units in the cluster with new versions."}, + }, + } } -func runSubmitUnits(args []string) (exit int) { +func runSubmitUnits(c *cli.Context, cAPI client.API) (exit int) { + args := c.Args() if len(args) == 0 { stderr("No units given") return 0 } - if err := lazyCreateUnits(args); err != nil { + if err := lazyCreateUnits(c, cAPI); err != nil { stderr("Error creating units: %v", err) exit = 1 } + return } diff --git a/fleetctl/submit_test.go b/fleetctl/submit_test.go index 949fef1f3..f6d791477 100644 --- a/fleetctl/submit_test.go +++ b/fleetctl/submit_test.go @@ -19,16 +19,19 @@ import ( "strings" "sync" "testing" + + "github.com/coreos/fleet/client" ) -func doSubmitUnits(r commandTestResults, errchan chan error) { - exit := runSubmitUnits(r.units) +func doSubmitUnits(t *testing.T, r commandTestResults, errchan chan error, cAPI client.API) { + c := createTestContext(t, append([]string{"submit"}, r.units...)...) + exit := runSubmitUnits(c, cAPI) if exit != r.expectedExit { errchan <- fmt.Errorf("%s: expected exit code %d but received %d", r.description, r.expectedExit, exit) return } - submitted, err := findUnits(r.units) + submitted, err := findUnits(r.units, cAPI) if err != nil { errchan <- err return @@ -67,12 +70,12 @@ func runSubmitUnitsTests(t *testing.T, unitPrefix string, results []commandTestR unitsCount = len(r.units) } - cAPI = newFakeRegistryForCommands(unitPrefix, unitsCount, template) + cAPI := newFakeRegistryForCommands(unitPrefix, unitsCount, template) wg.Add(1) go func() { defer wg.Done() - doSubmitUnits(r, errchan) + doSubmitUnits(t, r, errchan, cAPI) }() go func() { @@ -88,10 +91,6 @@ func runSubmitUnitsTests(t *testing.T, unitPrefix string, results []commandTestR func TestRunSubmitUnits(t *testing.T) { unitPrefix := "submit" - oldNoBlock := sharedFlags.NoBlock - defer func() { - sharedFlags.NoBlock = oldNoBlock - }() results := []commandTestResults{ { @@ -154,7 +153,6 @@ func TestRunSubmitUnits(t *testing.T) { }, } - sharedFlags.NoBlock = true runSubmitUnitsTests(t, unitPrefix, results, false) runSubmitUnitsTests(t, unitPrefix, templateResults, true) } diff --git a/fleetctl/unload.go b/fleetctl/unload.go index dd1e067fc..486dcf55f 100644 --- a/fleetctl/unload.go +++ b/fleetctl/unload.go @@ -17,31 +17,34 @@ package main import ( "os" + "github.com/codegangsta/cli" + + "github.com/coreos/fleet/client" "github.com/coreos/fleet/job" "github.com/coreos/fleet/log" ) -var ( - cmdUnloadUnit = &Command{ - Name: "unload", - Summary: "Unschedule one or more units in the cluster.", - Usage: "UNIT...", - Run: runUnloadUnit, +func NewUnloadUnitCommand() cli.Command { + return cli.Command{ + Name: "unload", + Usage: "Unschedule one or more units in the cluster.", + ArgsUsage: "UNIT...", + Action: makeActionWrapper(runUnloadUnit), + Flags: []cli.Flag{ + cli.IntFlag{Name: "block-attempts", Value: 0, Usage: "Wait until the units are inactive, performing up to N attempts before giving up. A value of 0 indicates no limit."}, + cli.BoolFlag{Name: "no-block", Usage: "Do not wait until the units have become inactive before exiting."}, + }, } -) - -func init() { - cmdUnloadUnit.Flags.IntVar(&sharedFlags.BlockAttempts, "block-attempts", 0, "Wait until the units are inactive, performing up to N attempts before giving up. A value of 0 indicates no limit.") - cmdUnloadUnit.Flags.BoolVar(&sharedFlags.NoBlock, "no-block", false, "Do not wait until the units have become inactive before exiting.") } -func runUnloadUnit(args []string) (exit int) { +func runUnloadUnit(c *cli.Context, cAPI client.API) (exit int) { + args := c.Args() if len(args) == 0 { stderr("No units given") return 0 } - units, err := findUnits(args) + units, err := findUnits(args, cAPI) if err != nil { stderr("%v", err) return 1 @@ -65,7 +68,7 @@ func runUnloadUnit(args []string) (exit int) { } } - exit = tryWaitForUnitStates(wait, "unload", job.JobStateInactive, getBlockAttempts(), os.Stdout) + exit = tryWaitForUnitStates(wait, "unload", job.JobStateInactive, getBlockAttempts(c), os.Stdout, cAPI) if exit == 0 { stderr("Successfully unloaded units %v.", wait) } else { diff --git a/fleetctl/unload_test.go b/fleetctl/unload_test.go index 169ebfea2..fe68782e4 100644 --- a/fleetctl/unload_test.go +++ b/fleetctl/unload_test.go @@ -19,17 +19,20 @@ import ( "sync" "testing" + "github.com/codegangsta/cli" + + "github.com/coreos/fleet/client" "github.com/coreos/fleet/job" ) -func doUnloadUnits(r commandTestResults, errchan chan error) { - exit := runUnloadUnit(r.units) +func doUnloadUnits(t *testing.T, r commandTestResults, errchan chan error, cAPI client.API, c *cli.Context) { + exit := runUnloadUnit(c, cAPI) if exit != r.expectedExit { errchan <- fmt.Errorf("%s: expected exit code %d but received %d", r.description, r.expectedExit, exit) return } - real_units, err := findUnits(r.units) + real_units, err := findUnits(r.units, cAPI) if err != nil { errchan <- err return @@ -45,10 +48,6 @@ func doUnloadUnits(r commandTestResults, errchan chan error) { func TestRunUnloadUnits(t *testing.T) { unitPrefix := "unload" - oldNoBlock := sharedFlags.NoBlock - defer func() { - sharedFlags.NoBlock = oldNoBlock - }() results := []commandTestResults{ { @@ -73,21 +72,22 @@ func TestRunUnloadUnits(t *testing.T) { }, } - sharedFlags.NoBlock = true for _, r := range results { var wg sync.WaitGroup errchan := make(chan error) - cAPI = newFakeRegistryForCommands(unitPrefix, len(r.units), false) + cAPI := newFakeRegistryForCommands(unitPrefix, len(r.units), false) + + c := createTestContext(t, append([]string{"unload", "--no-block"}, r.units...)...) wg.Add(2) go func() { defer wg.Done() - doUnloadUnits(r, errchan) + doUnloadUnits(t, r, errchan, cAPI, c) }() go func() { defer wg.Done() - doUnloadUnits(r, errchan) + doUnloadUnits(t, r, errchan, cAPI, c) }() go func() { diff --git a/fleetctl/verify.go b/fleetctl/verify.go index acde2e01c..2081982b2 100644 --- a/fleetctl/verify.go +++ b/fleetctl/verify.go @@ -14,14 +14,22 @@ package main -var cmdVerifyUnit = &Command{ - Name: "verify", - Summary: "DEPRECATED - No longer works", - Usage: "UNIT", - Run: runVerifyUnit, +import ( + "github.com/codegangsta/cli" + + "github.com/coreos/fleet/client" +) + +func NewVerifyCommand() cli.Command { + return cli.Command{ + Name: "verify", + Usage: "DEPRECATED - No longer works", + ArgsUsage: "UNIT", + Action: makeActionWrapper(runVerifyUnit), + } } -func runVerifyUnit(args []string) (exit int) { +func runVerifyUnit(c *cli.Context, cAPI client.API) (exit int) { stderr("WARNING: The signed/verified units feature is DEPRECATED and cannot be used.") return 2 } diff --git a/fleetctl/version.go b/fleetctl/version.go deleted file mode 100644 index 207b4f243..000000000 --- a/fleetctl/version.go +++ /dev/null @@ -1,31 +0,0 @@ -// Copyright 2014 CoreOS, Inc. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package main - -import ( - "github.com/coreos/fleet/version" -) - -var cmdVersion = &Command{ - Name: "version", - Description: "Print the version and exit", - Summary: "Print the version and exit", - Run: runVersion, -} - -func runVersion(args []string) (exit int) { - stdout("fleetctl version %s", version.Version) - return -} From 606869a9c5b95bc4b08e2a57b33f5620d7e7bf91 Mon Sep 17 00:00:00 2001 From: Dongsu Park Date: Fri, 13 May 2016 21:41:30 +0200 Subject: [PATCH 2/6] vendor github.com/spf13/{cobra,pflag} Add github.com/spf13/cobra and github.com/spf13/pflag. --- vendor/github.com/spf13/cobra/LICENSE.txt | 174 +++ vendor/github.com/spf13/cobra/README.md | 892 ++++++++++++ .../spf13/cobra/bash_completions.go | 602 ++++++++ .../spf13/cobra/bash_completions.md | 206 +++ .../spf13/cobra/bash_completions_test.go | 140 ++ vendor/github.com/spf13/cobra/cobra.go | 171 +++ vendor/github.com/spf13/cobra/cobra_test.go | 1188 ++++++++++++++++ vendor/github.com/spf13/cobra/command.go | 1217 +++++++++++++++++ .../github.com/spf13/cobra/command_notwin.go | 5 + vendor/github.com/spf13/cobra/command_test.go | 114 ++ vendor/github.com/spf13/cobra/command_win.go | 26 + vendor/github.com/spf13/pflag/LICENSE | 28 + vendor/github.com/spf13/pflag/README.md | 256 ++++ vendor/github.com/spf13/pflag/bool.go | 97 ++ vendor/github.com/spf13/pflag/bool_test.go | 180 +++ vendor/github.com/spf13/pflag/count.go | 97 ++ vendor/github.com/spf13/pflag/count_test.go | 55 + vendor/github.com/spf13/pflag/duration.go | 86 ++ vendor/github.com/spf13/pflag/example_test.go | 77 ++ vendor/github.com/spf13/pflag/export_test.go | 29 + vendor/github.com/spf13/pflag/flag.go | 934 +++++++++++++ vendor/github.com/spf13/pflag/flag_test.go | 913 +++++++++++++ vendor/github.com/spf13/pflag/float32.go | 91 ++ vendor/github.com/spf13/pflag/float64.go | 87 ++ vendor/github.com/spf13/pflag/golangflag.go | 104 ++ .../github.com/spf13/pflag/golangflag_test.go | 39 + vendor/github.com/spf13/pflag/int.go | 87 ++ vendor/github.com/spf13/pflag/int32.go | 91 ++ vendor/github.com/spf13/pflag/int64.go | 87 ++ vendor/github.com/spf13/pflag/int8.go | 91 ++ vendor/github.com/spf13/pflag/int_slice.go | 128 ++ .../github.com/spf13/pflag/int_slice_test.go | 162 +++ vendor/github.com/spf13/pflag/ip.go | 96 ++ vendor/github.com/spf13/pflag/ip_test.go | 63 + vendor/github.com/spf13/pflag/ipmask.go | 122 ++ vendor/github.com/spf13/pflag/ipnet.go | 100 ++ vendor/github.com/spf13/pflag/ipnet_test.go | 70 + vendor/github.com/spf13/pflag/string.go | 82 ++ vendor/github.com/spf13/pflag/string_slice.go | 111 ++ .../spf13/pflag/string_slice_test.go | 161 +++ vendor/github.com/spf13/pflag/uint.go | 91 ++ vendor/github.com/spf13/pflag/uint16.go | 89 ++ vendor/github.com/spf13/pflag/uint32.go | 89 ++ vendor/github.com/spf13/pflag/uint64.go | 91 ++ vendor/github.com/spf13/pflag/uint8.go | 91 ++ vendor/github.com/spf13/pflag/verify/all.sh | 69 + vendor/github.com/spf13/pflag/verify/gofmt.sh | 19 + .../github.com/spf13/pflag/verify/golint.sh | 15 + 48 files changed, 9813 insertions(+) create mode 100644 vendor/github.com/spf13/cobra/LICENSE.txt create mode 100644 vendor/github.com/spf13/cobra/README.md create mode 100644 vendor/github.com/spf13/cobra/bash_completions.go create mode 100644 vendor/github.com/spf13/cobra/bash_completions.md create mode 100644 vendor/github.com/spf13/cobra/bash_completions_test.go create mode 100644 vendor/github.com/spf13/cobra/cobra.go create mode 100644 vendor/github.com/spf13/cobra/cobra_test.go create mode 100644 vendor/github.com/spf13/cobra/command.go create mode 100644 vendor/github.com/spf13/cobra/command_notwin.go create mode 100644 vendor/github.com/spf13/cobra/command_test.go create mode 100644 vendor/github.com/spf13/cobra/command_win.go create mode 100644 vendor/github.com/spf13/pflag/LICENSE create mode 100644 vendor/github.com/spf13/pflag/README.md create mode 100644 vendor/github.com/spf13/pflag/bool.go create mode 100644 vendor/github.com/spf13/pflag/bool_test.go create mode 100644 vendor/github.com/spf13/pflag/count.go create mode 100644 vendor/github.com/spf13/pflag/count_test.go create mode 100644 vendor/github.com/spf13/pflag/duration.go create mode 100644 vendor/github.com/spf13/pflag/example_test.go create mode 100644 vendor/github.com/spf13/pflag/export_test.go create mode 100644 vendor/github.com/spf13/pflag/flag.go create mode 100644 vendor/github.com/spf13/pflag/flag_test.go create mode 100644 vendor/github.com/spf13/pflag/float32.go create mode 100644 vendor/github.com/spf13/pflag/float64.go create mode 100644 vendor/github.com/spf13/pflag/golangflag.go create mode 100644 vendor/github.com/spf13/pflag/golangflag_test.go create mode 100644 vendor/github.com/spf13/pflag/int.go create mode 100644 vendor/github.com/spf13/pflag/int32.go create mode 100644 vendor/github.com/spf13/pflag/int64.go create mode 100644 vendor/github.com/spf13/pflag/int8.go create mode 100644 vendor/github.com/spf13/pflag/int_slice.go create mode 100644 vendor/github.com/spf13/pflag/int_slice_test.go create mode 100644 vendor/github.com/spf13/pflag/ip.go create mode 100644 vendor/github.com/spf13/pflag/ip_test.go create mode 100644 vendor/github.com/spf13/pflag/ipmask.go create mode 100644 vendor/github.com/spf13/pflag/ipnet.go create mode 100644 vendor/github.com/spf13/pflag/ipnet_test.go create mode 100644 vendor/github.com/spf13/pflag/string.go create mode 100644 vendor/github.com/spf13/pflag/string_slice.go create mode 100644 vendor/github.com/spf13/pflag/string_slice_test.go create mode 100644 vendor/github.com/spf13/pflag/uint.go create mode 100644 vendor/github.com/spf13/pflag/uint16.go create mode 100644 vendor/github.com/spf13/pflag/uint32.go create mode 100644 vendor/github.com/spf13/pflag/uint64.go create mode 100644 vendor/github.com/spf13/pflag/uint8.go create mode 100755 vendor/github.com/spf13/pflag/verify/all.sh create mode 100755 vendor/github.com/spf13/pflag/verify/gofmt.sh create mode 100755 vendor/github.com/spf13/pflag/verify/golint.sh diff --git a/vendor/github.com/spf13/cobra/LICENSE.txt b/vendor/github.com/spf13/cobra/LICENSE.txt new file mode 100644 index 000000000..298f0e266 --- /dev/null +++ b/vendor/github.com/spf13/cobra/LICENSE.txt @@ -0,0 +1,174 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. diff --git a/vendor/github.com/spf13/cobra/README.md b/vendor/github.com/spf13/cobra/README.md new file mode 100644 index 000000000..34c79eb8e --- /dev/null +++ b/vendor/github.com/spf13/cobra/README.md @@ -0,0 +1,892 @@ +![cobra logo](https://cloud.githubusercontent.com/assets/173412/10886352/ad566232-814f-11e5-9cd0-aa101788c117.png) + +Cobra is both a library for creating powerful modern CLI applications as well as a program to generate applications and command files. + +Many of the most widely used Go projects are built using Cobra including: + +* [Kubernetes](http://kubernetes.io/) +* [Hugo](http://gohugo.io) +* [rkt](https://github.com/coreos/rkt) +* [etcd](https://github.com/coreos/etcd) +* [Docker (distribution)](https://github.com/docker/distribution) +* [OpenShift](https://www.openshift.com/) +* [Delve](https://github.com/derekparker/delve) +* [GopherJS](http://www.gopherjs.org/) +* [CockroachDB](http://www.cockroachlabs.com/) +* [Bleve](http://www.blevesearch.com/) +* [ProjectAtomic (enterprise)](http://www.projectatomic.io/) +* [Parse (CLI)](https://parse.com/) +* [GiantSwarm's swarm](https://github.com/giantswarm/cli) +* [Nanobox](https://github.com/nanobox-io/nanobox)/[Nanopack](https://github.com/nanopack) + + +[![Build Status](https://travis-ci.org/spf13/cobra.svg "Travis CI status")](https://travis-ci.org/spf13/cobra) +[![CircleCI status](https://circleci.com/gh/spf13/cobra.png?circle-token=:circle-token "CircleCI status")](https://circleci.com/gh/spf13/cobra) +[![GoDoc](https://godoc.org/github.com/spf13/cobra?status.svg)](https://godoc.org/github.com/spf13/cobra) + +![cobra](https://cloud.githubusercontent.com/assets/173412/10911369/84832a8e-8212-11e5-9f82-cc96660a4794.gif) + +# Overview + +Cobra is a library providing a simple interface to create powerful modern CLI +interfaces similar to git & go tools. + +Cobra is also an application that will generate your application scaffolding to rapidly +develop a Cobra-based application. + +Cobra provides: +* Easy subcommand-based CLIs: `app server`, `app fetch`, etc. +* Fully POSIX-compliant flags (including short & long versions) +* Nested subcommands +* Global, local and cascading flags +* Easy generation of applications & commands with `cobra create appname` & `cobra add cmdname` +* Intelligent suggestions (`app srver`... did you mean `app server`?) +* Automatic help generation for commands and flags +* Automatic detailed help for `app help [command]` +* Automatic help flag recognition of `-h`, `--help`, etc. +* Automatically generated bash autocomplete for your application +* Automatically generated man pages for your application +* Command aliases so you can change things without breaking them +* The flexibilty to define your own help, usage, etc. +* Optional tight integration with [viper](http://github.com/spf13/viper) for 12-factor apps + +Cobra has an exceptionally clean interface and simple design without needless +constructors or initialization methods. + +Applications built with Cobra commands are designed to be as user-friendly as +possible. Flags can be placed before or after the command (as long as a +confusing space isn’t provided). Both short and long flags can be used. A +command need not even be fully typed. Help is automatically generated and +available for the application or for a specific command using either the help +command or the `--help` flag. + +# Concepts + +Cobra is built on a structure of commands, arguments & flags. + +**Commands** represent actions, **Args** are things and **Flags** are modifiers for those actions. + +The best applications will read like sentences when used. Users will know how +to use the application because they will natively understand how to use it. + +The pattern to follow is +`APPNAME VERB NOUN --ADJECTIVE.` + or +`APPNAME COMMAND ARG --FLAG` + +A few good real world examples may better illustrate this point. + +In the following example, 'server' is a command, and 'port' is a flag: + + > hugo server --port=1313 + +In this command we are telling Git to clone the url bare. + + > git clone URL --bare + +## Commands + +Command is the central point of the application. Each interaction that +the application supports will be contained in a Command. A command can +have children commands and optionally run an action. + +In the example above, 'server' is the command. + +A Command has the following structure: + +```go +type Command struct { + Use string // The one-line usage message. + Short string // The short description shown in the 'help' output. + Long string // The long message shown in the 'help ' output. + Run func(cmd *Command, args []string) // Run runs the command. +} +``` + +## Flags + +A Flag is a way to modify the behavior of a command. Cobra supports +fully POSIX-compliant flags as well as the Go [flag package](https://golang.org/pkg/flag/). +A Cobra command can define flags that persist through to children commands +and flags that are only available to that command. + +In the example above, 'port' is the flag. + +Flag functionality is provided by the [pflag +library](https://github.com/ogier/pflag), a fork of the flag standard library +which maintains the same interface while adding POSIX compliance. + +## Usage + +Cobra works by creating a set of commands and then organizing them into a tree. +The tree defines the structure of the application. + +Once each command is defined with its corresponding flags, then the +tree is assigned to the commander which is finally executed. + +# Installing +Using Cobra is easy. First, use `go get` to install the latest version +of the library. This command will install the `cobra` generator executible +along with the library: + + > go get -v github.com/spf13/cobra/cobra + +Next, include Cobra in your application: + +```go +import "github.com/spf13/cobra" +``` + +# Getting Started + +While you are welcome to provide your own organization, typically a Cobra based +application will follow the following organizational structure. + +``` + ▾ appName/ + ▾ cmd/ + add.go + your.go + commands.go + here.go + main.go +``` + +In a Cobra app, typically the main.go file is very bare. It serves, one purpose, to initialize Cobra. + +```go +package main + +import "{pathToYourApp}/cmd" + +func main() { + if err := cmd.RootCmd.Execute(); err != nil { + fmt.Println(err) + os.Exit(-1) + } +} +``` + +## Using the Cobra Generator + +Cobra provides its own program that will create your application and add any +commands you want. It's the easiest way to incorporate Cobra into your application. + +### cobra init + +The `cobra init [yourApp]` command will create your initial application code +for you. It is a very powerful application that will populate your program with +the right structure so you can immediately enjoy all the benefits of Cobra. It +will also automatically apply the license you specify to your application. + +Cobra init is pretty smart. You can provide it a full path, or simply a path +similar to what is expected in the import. + +``` +cobra init github.com/spf13/newAppName +``` + +### cobra add + +Once an application is initialized Cobra can create additional commands for you. +Let's say you created an app and you wanted the following commands for it: + +* app serve +* app config +* app config create + +In your project directory (where your main.go file is) you would run the following: + +``` +cobra add serve +cobra add config +cobra add create -p 'configCmd' +``` + +Once you have run these three commands you would have an app structure that would look like: + +``` + ▾ app/ + ▾ cmd/ + serve.go + config.go + create.go + main.go +``` + +at this point you can run `go run main.go` and it would run your app. `go run +main.go serve`, `go run main.go config`, `go run main.go config create` along +with `go run main.go help serve`, etc would all work. + +Obviously you haven't added your own code to these yet, the commands are ready +for you to give them their tasks. Have fun. + +### Configuring the cobra generator + +The cobra generator will be easier to use if you provide a simple configuration +file which will help you eliminate providing a bunch of repeated information in +flags over and over. + +An example ~/.cobra.yaml file: + +```yaml +author: Steve Francia +license: MIT +``` + +You can specify no license by setting `license` to `none` or you can specify +a custom license: + +```yaml +license: + header: This file is part of {{ .appName }}. + text: | + {{ .copyright }} + + This is my license. There are many like it, but this one is mine. + My license is my best friend. It is my life. I must master it as I must + master my life. +``` + +## Manually implementing Cobra + +To manually implement cobra you need to create a bare main.go file and a RootCmd file. +You will optionally provide additional commands as you see fit. + +### Create the root command + +The root command represents your binary itself. + + +#### Manually create rootCmd + +Cobra doesn't require any special constructors. Simply create your commands. + +Ideally you place this in app/cmd/root.go: + +```go +var RootCmd = &cobra.Command{ + Use: "hugo", + Short: "Hugo is a very fast static site generator", + Long: `A Fast and Flexible Static Site Generator built with + love by spf13 and friends in Go. + Complete documentation is available at http://hugo.spf13.com`, + Run: func(cmd *cobra.Command, args []string) { + // Do Stuff Here + }, +} +``` + +You will additionally define flags and handle configuration in your init() function. + +for example cmd/root.go: + +```go +func init() { + cobra.OnInitialize(initConfig) + RootCmd.PersistentFlags().StringVar(&cfgFile, "config", "", "config file (default is $HOME/.cobra.yaml)") + RootCmd.PersistentFlags().StringVarP(&projectBase, "projectbase", "b", "", "base project directory eg. github.com/spf13/") + RootCmd.PersistentFlags().StringP("author", "a", "YOUR NAME", "Author name for copyright attribution") + RootCmd.PersistentFlags().StringVarP(&userLicense, "license", "l", "", "Name of license for the project (can provide `licensetext` in config)") + RootCmd.PersistentFlags().Bool("viper", true, "Use Viper for configuration") + viper.BindPFlag("author", RootCmd.PersistentFlags().Lookup("author")) + viper.BindPFlag("projectbase", RootCmd.PersistentFlags().Lookup("projectbase")) + viper.BindPFlag("useViper", RootCmd.PersistentFlags().Lookup("viper")) + viper.SetDefault("author", "NAME HERE ") + viper.SetDefault("license", "apache") +} +``` + +### Create your main.go + +With the root command you need to have your main function execute it. +Execute should be run on the root for clarity, though it can be called on any command. + +In a Cobra app, typically the main.go file is very bare. It serves, one purpose, to initialize Cobra. + +```go +package main + +import "{pathToYourApp}/cmd" + +func main() { + if err := cmd.RootCmd.Execute(); err != nil { + fmt.Println(err) + os.Exit(-1) + } +} +``` + + +### Create additional commands + +Additional commands can be defined and typically are each given their own file +inside of the cmd/ directory. + +If you wanted to create a version command you would create cmd/version.go and +populate it with the following: + +```go +package cmd + +import ( + "github.com/spf13/cobra" +) + +func init() { + RootCmd.AddCommand(versionCmd) +} + +var versionCmd = &cobra.Command{ + Use: "version", + Short: "Print the version number of Hugo", + Long: `All software has versions. This is Hugo's`, + Run: func(cmd *cobra.Command, args []string) { + fmt.Println("Hugo Static Site Generator v0.9 -- HEAD") + }, +} +``` + +### Attach command to its parent + + +If you notice in the above example we attach the command to its parent. In +this case the parent is the rootCmd. In this example we are attaching it to the +root, but commands can be attached at any level. + +```go +RootCmd.AddCommand(versionCmd) +``` + +### Remove a command from its parent + +Removing a command is not a common action in simple programs, but it allows 3rd +parties to customize an existing command tree. + +In this example, we remove the existing `VersionCmd` command of an existing +root command, and we replace it with our own version: + +```go +mainlib.RootCmd.RemoveCommand(mainlib.VersionCmd) +mainlib.RootCmd.AddCommand(versionCmd) +``` + +## Working with Flags + +Flags provide modifiers to control how the action command operates. + +### Assign flags to a command + +Since the flags are defined and used in different locations, we need to +define a variable outside with the correct scope to assign the flag to +work with. + +```go +var Verbose bool +var Source string +``` + +There are two different approaches to assign a flag. + +### Persistent Flags + +A flag can be 'persistent' meaning that this flag will be available to the +command it's assigned to as well as every command under that command. For +global flags, assign a flag as a persistent flag on the root. + +```go +RootCmd.PersistentFlags().BoolVarP(&Verbose, "verbose", "v", false, "verbose output") +``` + +### Local Flags + +A flag can also be assigned locally which will only apply to that specific command. + +```go +RootCmd.Flags().StringVarP(&Source, "source", "s", "", "Source directory to read from") +``` + + +## Example + +In the example below, we have defined three commands. Two are at the top level +and one (cmdTimes) is a child of one of the top commands. In this case the root +is not executable meaning that a subcommand is required. This is accomplished +by not providing a 'Run' for the 'rootCmd'. + +We have only defined one flag for a single command. + +More documentation about flags is available at https://github.com/spf13/pflag + +```go +package main + +import ( + "fmt" + "strings" + + "github.com/spf13/cobra" +) + +func main() { + + var echoTimes int + + var cmdPrint = &cobra.Command{ + Use: "print [string to print]", + Short: "Print anything to the screen", + Long: `print is for printing anything back to the screen. + For many years people have printed back to the screen. + `, + Run: func(cmd *cobra.Command, args []string) { + fmt.Println("Print: " + strings.Join(args, " ")) + }, + } + + var cmdEcho = &cobra.Command{ + Use: "echo [string to echo]", + Short: "Echo anything to the screen", + Long: `echo is for echoing anything back. + Echo works a lot like print, except it has a child command. + `, + Run: func(cmd *cobra.Command, args []string) { + fmt.Println("Print: " + strings.Join(args, " ")) + }, + } + + var cmdTimes = &cobra.Command{ + Use: "times [# times] [string to echo]", + Short: "Echo anything to the screen more times", + Long: `echo things multiple times back to the user by providing + a count and a string.`, + Run: func(cmd *cobra.Command, args []string) { + for i := 0; i < echoTimes; i++ { + fmt.Println("Echo: " + strings.Join(args, " ")) + } + }, + } + + cmdTimes.Flags().IntVarP(&echoTimes, "times", "t", 1, "times to echo the input") + + var rootCmd = &cobra.Command{Use: "app"} + rootCmd.AddCommand(cmdPrint, cmdEcho) + cmdEcho.AddCommand(cmdTimes) + rootCmd.Execute() +} +``` + +For a more complete example of a larger application, please checkout [Hugo](http://gohugo.io/). + +## The Help Command + +Cobra automatically adds a help command to your application when you have subcommands. +This will be called when a user runs 'app help'. Additionally, help will also +support all other commands as input. Say, for instance, you have a command called +'create' without any additional configuration; Cobra will work when 'app help +create' is called. Every command will automatically have the '--help' flag added. + +### Example + +The following output is automatically generated by Cobra. Nothing beyond the +command and flag definitions are needed. + + > hugo help + + hugo is the main command, used to build your Hugo site. + + Hugo is a Fast and Flexible Static Site Generator + built with love by spf13 and friends in Go. + + Complete documentation is available at http://gohugo.io/. + + Usage: + hugo [flags] + hugo [command] + + Available Commands: + server Hugo runs its own webserver to render the files + version Print the version number of Hugo + config Print the site configuration + check Check content in the source directory + benchmark Benchmark hugo by building a site a number of times. + convert Convert your content to different formats + new Create new content for your site + list Listing out various types of content + undraft Undraft changes the content's draft status from 'True' to 'False' + genautocomplete Generate shell autocompletion script for Hugo + gendoc Generate Markdown documentation for the Hugo CLI. + genman Generate man page for Hugo + import Import your site from others. + + Flags: + -b, --baseURL="": hostname (and path) to the root, e.g. http://spf13.com/ + -D, --buildDrafts[=false]: include content marked as draft + -F, --buildFuture[=false]: include content with publishdate in the future + --cacheDir="": filesystem path to cache directory. Defaults: $TMPDIR/hugo_cache/ + --canonifyURLs[=false]: if true, all relative URLs will be canonicalized using baseURL + --config="": config file (default is path/config.yaml|json|toml) + -d, --destination="": filesystem path to write files to + --disableRSS[=false]: Do not build RSS files + --disableSitemap[=false]: Do not build Sitemap file + --editor="": edit new content with this editor, if provided + --ignoreCache[=false]: Ignores the cache directory for reading but still writes to it + --log[=false]: Enable Logging + --logFile="": Log File path (if set, logging enabled automatically) + --noTimes[=false]: Don't sync modification time of files + --pluralizeListTitles[=true]: Pluralize titles in lists using inflect + --preserveTaxonomyNames[=false]: Preserve taxonomy names as written ("Gérard Depardieu" vs "gerard-depardieu") + -s, --source="": filesystem path to read files relative from + --stepAnalysis[=false]: display memory and timing of different steps of the program + -t, --theme="": theme to use (located in /themes/THEMENAME/) + --uglyURLs[=false]: if true, use /filename.html instead of /filename/ + -v, --verbose[=false]: verbose output + --verboseLog[=false]: verbose logging + -w, --watch[=false]: watch filesystem for changes and recreate as needed + + Use "hugo [command] --help" for more information about a command. + + +Help is just a command like any other. There is no special logic or behavior +around it. In fact, you can provide your own if you want. + +### Defining your own help + +You can provide your own Help command or your own template for the default command to use. + +The default help command is + +```go +func (c *Command) initHelp() { + if c.helpCommand == nil { + c.helpCommand = &Command{ + Use: "help [command]", + Short: "Help about any command", + Long: `Help provides help for any command in the application. + Simply type ` + c.Name() + ` help [path to command] for full details.`, + Run: c.HelpFunc(), + } + } + c.AddCommand(c.helpCommand) +} +``` + +You can provide your own command, function or template through the following methods: + +```go +command.SetHelpCommand(cmd *Command) + +command.SetHelpFunc(f func(*Command, []string)) + +command.SetHelpTemplate(s string) +``` + +The latter two will also apply to any children commands. + +## Usage + +When the user provides an invalid flag or invalid command, Cobra responds by +showing the user the 'usage'. + +### Example +You may recognize this from the help above. That's because the default help +embeds the usage as part of its output. + + Usage: + hugo [flags] + hugo [command] + + Available Commands: + server Hugo runs its own webserver to render the files + version Print the version number of Hugo + config Print the site configuration + check Check content in the source directory + benchmark Benchmark hugo by building a site a number of times. + convert Convert your content to different formats + new Create new content for your site + list Listing out various types of content + undraft Undraft changes the content's draft status from 'True' to 'False' + genautocomplete Generate shell autocompletion script for Hugo + gendoc Generate Markdown documentation for the Hugo CLI. + genman Generate man page for Hugo + import Import your site from others. + + Flags: + -b, --baseURL="": hostname (and path) to the root, e.g. http://spf13.com/ + -D, --buildDrafts[=false]: include content marked as draft + -F, --buildFuture[=false]: include content with publishdate in the future + --cacheDir="": filesystem path to cache directory. Defaults: $TMPDIR/hugo_cache/ + --canonifyURLs[=false]: if true, all relative URLs will be canonicalized using baseURL + --config="": config file (default is path/config.yaml|json|toml) + -d, --destination="": filesystem path to write files to + --disableRSS[=false]: Do not build RSS files + --disableSitemap[=false]: Do not build Sitemap file + --editor="": edit new content with this editor, if provided + --ignoreCache[=false]: Ignores the cache directory for reading but still writes to it + --log[=false]: Enable Logging + --logFile="": Log File path (if set, logging enabled automatically) + --noTimes[=false]: Don't sync modification time of files + --pluralizeListTitles[=true]: Pluralize titles in lists using inflect + --preserveTaxonomyNames[=false]: Preserve taxonomy names as written ("Gérard Depardieu" vs "gerard-depardieu") + -s, --source="": filesystem path to read files relative from + --stepAnalysis[=false]: display memory and timing of different steps of the program + -t, --theme="": theme to use (located in /themes/THEMENAME/) + --uglyURLs[=false]: if true, use /filename.html instead of /filename/ + -v, --verbose[=false]: verbose output + --verboseLog[=false]: verbose logging + -w, --watch[=false]: watch filesystem for changes and recreate as needed + +### Defining your own usage +You can provide your own usage function or template for Cobra to use. + +The default usage function is: + +```go +return func(c *Command) error { + err := tmpl(c.Out(), c.UsageTemplate(), c) + return err +} +``` + +Like help, the function and template are overridable through public methods: + +```go +command.SetUsageFunc(f func(*Command) error) + +command.SetUsageTemplate(s string) +``` + +## PreRun or PostRun Hooks + +It is possible to run functions before or after the main `Run` function of your command. The `PersistentPreRun` and `PreRun` functions will be executed before `Run`. `PersistentPostRun` and `PostRun` will be executed after `Run`. The `Persistent*Run` functions will be inherrited by children if they do not declare their own. These function are run in the following order: + +- `PersistentPreRun` +- `PreRun` +- `Run` +- `PostRun` +- `PersistentPostRun` + +An example of two commands which use all of these features is below. When the subcommand is executed, it will run the root command's `PersistentPreRun` but not the root command's `PersistentPostRun`: + +```go +package main + +import ( + "fmt" + + "github.com/spf13/cobra" +) + +func main() { + + var rootCmd = &cobra.Command{ + Use: "root [sub]", + Short: "My root command", + PersistentPreRun: func(cmd *cobra.Command, args []string) { + fmt.Printf("Inside rootCmd PersistentPreRun with args: %v\n", args) + }, + PreRun: func(cmd *cobra.Command, args []string) { + fmt.Printf("Inside rootCmd PreRun with args: %v\n", args) + }, + Run: func(cmd *cobra.Command, args []string) { + fmt.Printf("Inside rootCmd Run with args: %v\n", args) + }, + PostRun: func(cmd *cobra.Command, args []string) { + fmt.Printf("Inside rootCmd PostRun with args: %v\n", args) + }, + PersistentPostRun: func(cmd *cobra.Command, args []string) { + fmt.Printf("Inside rootCmd PersistentPostRun with args: %v\n", args) + }, + } + + var subCmd = &cobra.Command{ + Use: "sub [no options!]", + Short: "My subcommand", + PreRun: func(cmd *cobra.Command, args []string) { + fmt.Printf("Inside subCmd PreRun with args: %v\n", args) + }, + Run: func(cmd *cobra.Command, args []string) { + fmt.Printf("Inside subCmd Run with args: %v\n", args) + }, + PostRun: func(cmd *cobra.Command, args []string) { + fmt.Printf("Inside subCmd PostRun with args: %v\n", args) + }, + PersistentPostRun: func(cmd *cobra.Command, args []string) { + fmt.Printf("Inside subCmd PersistentPostRun with args: %v\n", args) + }, + } + + rootCmd.AddCommand(subCmd) + + rootCmd.SetArgs([]string{""}) + _ = rootCmd.Execute() + fmt.Print("\n") + rootCmd.SetArgs([]string{"sub", "arg1", "arg2"}) + _ = rootCmd.Execute() +} +``` + + +## Alternative Error Handling + +Cobra also has functions where the return signature is an error. This allows for errors to bubble up to the top, +providing a way to handle the errors in one location. The current list of functions that return an error is: + +* PersistentPreRunE +* PreRunE +* RunE +* PostRunE +* PersistentPostRunE + +If you would like to silence the default `error` and `usage` output in favor of your own, you can set `SilenceUsage` +and `SilenceErrors` to `false` on the command. A child command respects these flags if they are set on the parent +command. + +**Example Usage using RunE:** + +```go +package main + +import ( + "errors" + "log" + + "github.com/spf13/cobra" +) + +func main() { + var rootCmd = &cobra.Command{ + Use: "hugo", + Short: "Hugo is a very fast static site generator", + Long: `A Fast and Flexible Static Site Generator built with + love by spf13 and friends in Go. + Complete documentation is available at http://hugo.spf13.com`, + RunE: func(cmd *cobra.Command, args []string) error { + // Do Stuff Here + return errors.New("some random error") + }, + } + + if err := rootCmd.Execute(); err != nil { + log.Fatal(err) + } +} +``` + +## Suggestions when "unknown command" happens + +Cobra will print automatic suggestions when "unknown command" errors happen. This allows Cobra to behave similarly to the `git` command when a typo happens. For example: + +``` +$ hugo srever +Error: unknown command "srever" for "hugo" + +Did you mean this? + server + +Run 'hugo --help' for usage. +``` + +Suggestions are automatic based on every subcommand registered and use an implementation of [Levenshtein distance](http://en.wikipedia.org/wiki/Levenshtein_distance). Every registered command that matches a minimum distance of 2 (ignoring case) will be displayed as a suggestion. + +If you need to disable suggestions or tweak the string distance in your command, use: + +```go +command.DisableSuggestions = true +``` + +or + +```go +command.SuggestionsMinimumDistance = 1 +``` + +You can also explicitly set names for which a given command will be suggested using the `SuggestFor` attribute. This allows suggestions for strings that are not close in terms of string distance, but makes sense in your set of commands and for some which you don't want aliases. Example: + +``` +$ kubectl remove +Error: unknown command "remove" for "kubectl" + +Did you mean this? + delete + +Run 'kubectl help' for usage. +``` + +## Generating Markdown-formatted documentation for your command + +Cobra can generate a Markdown-formatted document based on the subcommands, flags, etc. A simple example of how to do this for your command can be found in [Markdown Docs](doc/md_docs.md). + +## Generating man pages for your command + +Cobra can generate a man page based on the subcommands, flags, etc. A simple example of how to do this for your command can be found in [Man Docs](doc/man_docs.md). + +## Generating bash completions for your command + +Cobra can generate a bash-completion file. If you add more information to your command, these completions can be amazingly powerful and flexible. Read more about it in [Bash Completions](bash_completions.md). + +## Debugging + +Cobra provides a ‘DebugFlags’ method on a command which, when called, will print +out everything Cobra knows about the flags for each command. + +### Example + +```go +command.DebugFlags() +``` + +## Release Notes +* **0.9.0** June 17, 2014 + * flags can appears anywhere in the args (provided they are unambiguous) + * --help prints usage screen for app or command + * Prefix matching for commands + * Cleaner looking help and usage output + * Extensive test suite +* **0.8.0** Nov 5, 2013 + * Reworked interface to remove commander completely + * Command now primary structure + * No initialization needed + * Usage & Help templates & functions definable at any level + * Updated Readme +* **0.7.0** Sept 24, 2013 + * Needs more eyes + * Test suite + * Support for automatic error messages + * Support for help command + * Support for printing to any io.Writer instead of os.Stderr + * Support for persistent flags which cascade down tree + * Ready for integration into Hugo +* **0.1.0** Sept 3, 2013 + * Implement first draft + +## Extensions + +Libraries for extending Cobra: + +* [cmdns](https://github.com/gosuri/cmdns): Enables name spacing a command's immediate children. It provides an alternative way to structure subcommands, similar to `heroku apps:create` and `ovrclk clusters:launch`. + +## ToDo +* Launch proper documentation site + +## Contributing + +1. Fork it +2. Create your feature branch (`git checkout -b my-new-feature`) +3. Commit your changes (`git commit -am 'Add some feature'`) +4. Push to the branch (`git push origin my-new-feature`) +5. Create new Pull Request + +## Contributors + +Names in no particular order: + +* [spf13](https://github.com/spf13), +[eparis](https://github.com/eparis), +[bep](https://github.com/bep), and many more! + +## License + +Cobra is released under the Apache 2.0 license. See [LICENSE.txt](https://github.com/spf13/cobra/blob/master/LICENSE.txt) + + +[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/spf13/cobra/trend.png)](https://bitdeli.com/free "Bitdeli Badge") diff --git a/vendor/github.com/spf13/cobra/bash_completions.go b/vendor/github.com/spf13/cobra/bash_completions.go new file mode 100644 index 000000000..3f33bb0ec --- /dev/null +++ b/vendor/github.com/spf13/cobra/bash_completions.go @@ -0,0 +1,602 @@ +package cobra + +import ( + "fmt" + "io" + "os" + "sort" + "strings" + + "github.com/spf13/pflag" +) + +const ( + BashCompFilenameExt = "cobra_annotation_bash_completion_filename_extentions" + BashCompCustom = "cobra_annotation_bash_completion_custom" + BashCompOneRequiredFlag = "cobra_annotation_bash_completion_one_required_flag" + BashCompSubdirsInDir = "cobra_annotation_bash_completion_subdirs_in_dir" +) + +func preamble(out io.Writer, name string) error { + _, err := fmt.Fprintf(out, "# bash completion for %-36s -*- shell-script -*-\n", name) + if err != nil { + return err + } + _, err = fmt.Fprint(out, ` +__debug() +{ + if [[ -n ${BASH_COMP_DEBUG_FILE} ]]; then + echo "$*" >> "${BASH_COMP_DEBUG_FILE}" + fi +} + +# Homebrew on Macs have version 1.3 of bash-completion which doesn't include +# _init_completion. This is a very minimal version of that function. +__my_init_completion() +{ + COMPREPLY=() + _get_comp_words_by_ref "$@" cur prev words cword +} + +__index_of_word() +{ + local w word=$1 + shift + index=0 + for w in "$@"; do + [[ $w = "$word" ]] && return + index=$((index+1)) + done + index=-1 +} + +__contains_word() +{ + local w word=$1; shift + for w in "$@"; do + [[ $w = "$word" ]] && return + done + return 1 +} + +__handle_reply() +{ + __debug "${FUNCNAME[0]}" + case $cur in + -*) + if [[ $(type -t compopt) = "builtin" ]]; then + compopt -o nospace + fi + local allflags + if [ ${#must_have_one_flag[@]} -ne 0 ]; then + allflags=("${must_have_one_flag[@]}") + else + allflags=("${flags[*]} ${two_word_flags[*]}") + fi + COMPREPLY=( $(compgen -W "${allflags[*]}" -- "$cur") ) + if [[ $(type -t compopt) = "builtin" ]]; then + [[ "${COMPREPLY[0]}" == *= ]] || compopt +o nospace + fi + + # complete after --flag=abc + if [[ $cur == *=* ]]; then + if [[ $(type -t compopt) = "builtin" ]]; then + compopt +o nospace + fi + + local index flag + flag="${cur%%=*}" + __index_of_word "${flag}" "${flags_with_completion[@]}" + if [[ ${index} -ge 0 ]]; then + COMPREPLY=() + PREFIX="" + cur="${cur#*=}" + ${flags_completion[${index}]} + if [ -n "${ZSH_VERSION}" ]; then + # zfs completion needs --flag= prefix + eval "COMPREPLY=( \"\${COMPREPLY[@]/#/${flag}=}\" )" + fi + fi + fi + return 0; + ;; + esac + + # check if we are handling a flag with special work handling + local index + __index_of_word "${prev}" "${flags_with_completion[@]}" + if [[ ${index} -ge 0 ]]; then + ${flags_completion[${index}]} + return + fi + + # we are parsing a flag and don't have a special handler, no completion + if [[ ${cur} != "${words[cword]}" ]]; then + return + fi + + local completions + if [[ ${#must_have_one_flag[@]} -ne 0 ]]; then + completions=("${must_have_one_flag[@]}") + elif [[ ${#must_have_one_noun[@]} -ne 0 ]]; then + completions=("${must_have_one_noun[@]}") + else + completions=("${commands[@]}") + fi + COMPREPLY=( $(compgen -W "${completions[*]}" -- "$cur") ) + + if [[ ${#COMPREPLY[@]} -eq 0 && ${#noun_aliases[@]} -gt 0 && ${#must_have_one_noun[@]} -ne 0 ]]; then + COMPREPLY=( $(compgen -W "${noun_aliases[*]}" -- "$cur") ) + fi + + if [[ ${#COMPREPLY[@]} -eq 0 ]]; then + declare -F __custom_func >/dev/null && __custom_func + fi + + __ltrim_colon_completions "$cur" +} + +# The arguments should be in the form "ext1|ext2|extn" +__handle_filename_extension_flag() +{ + local ext="$1" + _filedir "@(${ext})" +} + +__handle_subdirs_in_dir_flag() +{ + local dir="$1" + pushd "${dir}" >/dev/null 2>&1 && _filedir -d && popd >/dev/null 2>&1 +} + +__handle_flag() +{ + __debug "${FUNCNAME[0]}: c is $c words[c] is ${words[c]}" + + # if a command required a flag, and we found it, unset must_have_one_flag() + local flagname=${words[c]} + local flagvalue + # if the word contained an = + if [[ ${words[c]} == *"="* ]]; then + flagvalue=${flagname#*=} # take in as flagvalue after the = + flagname=${flagname%%=*} # strip everything after the = + flagname="${flagname}=" # but put the = back + fi + __debug "${FUNCNAME[0]}: looking for ${flagname}" + if __contains_word "${flagname}" "${must_have_one_flag[@]}"; then + must_have_one_flag=() + fi + + # keep flag value with flagname as flaghash + if [ -n "${flagvalue}" ] ; then + flaghash[${flagname}]=${flagvalue} + elif [ -n "${words[ $((c+1)) ]}" ] ; then + flaghash[${flagname}]=${words[ $((c+1)) ]} + else + flaghash[${flagname}]="true" # pad "true" for bool flag + fi + + # skip the argument to a two word flag + if __contains_word "${words[c]}" "${two_word_flags[@]}"; then + c=$((c+1)) + # if we are looking for a flags value, don't show commands + if [[ $c -eq $cword ]]; then + commands=() + fi + fi + + c=$((c+1)) + +} + +__handle_noun() +{ + __debug "${FUNCNAME[0]}: c is $c words[c] is ${words[c]}" + + if __contains_word "${words[c]}" "${must_have_one_noun[@]}"; then + must_have_one_noun=() + elif __contains_word "${words[c]}" "${noun_aliases[@]}"; then + must_have_one_noun=() + fi + + nouns+=("${words[c]}") + c=$((c+1)) +} + +__handle_command() +{ + __debug "${FUNCNAME[0]}: c is $c words[c] is ${words[c]}" + + local next_command + if [[ -n ${last_command} ]]; then + next_command="_${last_command}_${words[c]//:/__}" + else + if [[ $c -eq 0 ]]; then + next_command="_$(basename "${words[c]//:/__}")" + else + next_command="_${words[c]//:/__}" + fi + fi + c=$((c+1)) + __debug "${FUNCNAME[0]}: looking for ${next_command}" + declare -F $next_command >/dev/null && $next_command +} + +__handle_word() +{ + if [[ $c -ge $cword ]]; then + __handle_reply + return + fi + __debug "${FUNCNAME[0]}: c is $c words[c] is ${words[c]}" + if [[ "${words[c]}" == -* ]]; then + __handle_flag + elif __contains_word "${words[c]}" "${commands[@]}"; then + __handle_command + elif [[ $c -eq 0 ]] && __contains_word "$(basename "${words[c]}")" "${commands[@]}"; then + __handle_command + else + __handle_noun + fi + __handle_word +} + +`) + return err +} + +func postscript(w io.Writer, name string) error { + name = strings.Replace(name, ":", "__", -1) + _, err := fmt.Fprintf(w, "__start_%s()\n", name) + if err != nil { + return err + } + _, err = fmt.Fprintf(w, `{ + local cur prev words cword + declare -A flaghash 2>/dev/null || : + if declare -F _init_completion >/dev/null 2>&1; then + _init_completion -s || return + else + __my_init_completion -n "=" || return + fi + + local c=0 + local flags=() + local two_word_flags=() + local flags_with_completion=() + local flags_completion=() + local commands=("%s") + local must_have_one_flag=() + local must_have_one_noun=() + local last_command + local nouns=() + + __handle_word +} + +`, name) + if err != nil { + return err + } + _, err = fmt.Fprintf(w, `if [[ $(type -t compopt) = "builtin" ]]; then + complete -o default -F __start_%s %s +else + complete -o default -o nospace -F __start_%s %s +fi + +`, name, name, name, name) + if err != nil { + return err + } + _, err = fmt.Fprintf(w, "# ex: ts=4 sw=4 et filetype=sh\n") + return err +} + +func writeCommands(cmd *Command, w io.Writer) error { + if _, err := fmt.Fprintf(w, " commands=()\n"); err != nil { + return err + } + for _, c := range cmd.Commands() { + if !c.IsAvailableCommand() || c == cmd.helpCommand { + continue + } + if _, err := fmt.Fprintf(w, " commands+=(%q)\n", c.Name()); err != nil { + return err + } + } + _, err := fmt.Fprintf(w, "\n") + return err +} + +func writeFlagHandler(name string, annotations map[string][]string, w io.Writer) error { + for key, value := range annotations { + switch key { + case BashCompFilenameExt: + _, err := fmt.Fprintf(w, " flags_with_completion+=(%q)\n", name) + if err != nil { + return err + } + + if len(value) > 0 { + ext := "__handle_filename_extension_flag " + strings.Join(value, "|") + _, err = fmt.Fprintf(w, " flags_completion+=(%q)\n", ext) + } else { + ext := "_filedir" + _, err = fmt.Fprintf(w, " flags_completion+=(%q)\n", ext) + } + if err != nil { + return err + } + case BashCompCustom: + _, err := fmt.Fprintf(w, " flags_with_completion+=(%q)\n", name) + if err != nil { + return err + } + if len(value) > 0 { + handlers := strings.Join(value, "; ") + _, err = fmt.Fprintf(w, " flags_completion+=(%q)\n", handlers) + } else { + _, err = fmt.Fprintf(w, " flags_completion+=(:)\n") + } + if err != nil { + return err + } + case BashCompSubdirsInDir: + _, err := fmt.Fprintf(w, " flags_with_completion+=(%q)\n", name) + + if len(value) == 1 { + ext := "__handle_subdirs_in_dir_flag " + value[0] + _, err = fmt.Fprintf(w, " flags_completion+=(%q)\n", ext) + } else { + ext := "_filedir -d" + _, err = fmt.Fprintf(w, " flags_completion+=(%q)\n", ext) + } + if err != nil { + return err + } + } + } + return nil +} + +func writeShortFlag(flag *pflag.Flag, w io.Writer) error { + b := (flag.Value.Type() == "bool") + name := flag.Shorthand + format := " " + if !b { + format += "two_word_" + } + format += "flags+=(\"-%s\")\n" + if _, err := fmt.Fprintf(w, format, name); err != nil { + return err + } + return writeFlagHandler("-"+name, flag.Annotations, w) +} + +func writeFlag(flag *pflag.Flag, w io.Writer) error { + b := (flag.Value.Type() == "bool") + name := flag.Name + format := " flags+=(\"--%s" + if !b { + format += "=" + } + format += "\")\n" + if _, err := fmt.Fprintf(w, format, name); err != nil { + return err + } + return writeFlagHandler("--"+name, flag.Annotations, w) +} + +func writeFlags(cmd *Command, w io.Writer) error { + _, err := fmt.Fprintf(w, ` flags=() + two_word_flags=() + flags_with_completion=() + flags_completion=() + +`) + if err != nil { + return err + } + var visitErr error + cmd.NonInheritedFlags().VisitAll(func(flag *pflag.Flag) { + if err := writeFlag(flag, w); err != nil { + visitErr = err + return + } + if len(flag.Shorthand) > 0 { + if err := writeShortFlag(flag, w); err != nil { + visitErr = err + return + } + } + }) + if visitErr != nil { + return visitErr + } + cmd.InheritedFlags().VisitAll(func(flag *pflag.Flag) { + if err := writeFlag(flag, w); err != nil { + visitErr = err + return + } + if len(flag.Shorthand) > 0 { + if err := writeShortFlag(flag, w); err != nil { + visitErr = err + return + } + } + }) + if visitErr != nil { + return visitErr + } + + _, err = fmt.Fprintf(w, "\n") + return err +} + +func writeRequiredFlag(cmd *Command, w io.Writer) error { + if _, err := fmt.Fprintf(w, " must_have_one_flag=()\n"); err != nil { + return err + } + flags := cmd.NonInheritedFlags() + var visitErr error + flags.VisitAll(func(flag *pflag.Flag) { + for key := range flag.Annotations { + switch key { + case BashCompOneRequiredFlag: + format := " must_have_one_flag+=(\"--%s" + b := (flag.Value.Type() == "bool") + if !b { + format += "=" + } + format += "\")\n" + if _, err := fmt.Fprintf(w, format, flag.Name); err != nil { + visitErr = err + return + } + + if len(flag.Shorthand) > 0 { + if _, err := fmt.Fprintf(w, " must_have_one_flag+=(\"-%s\")\n", flag.Shorthand); err != nil { + visitErr = err + return + } + } + } + } + }) + return visitErr +} + +func writeRequiredNouns(cmd *Command, w io.Writer) error { + if _, err := fmt.Fprintf(w, " must_have_one_noun=()\n"); err != nil { + return err + } + sort.Sort(sort.StringSlice(cmd.ValidArgs)) + for _, value := range cmd.ValidArgs { + if _, err := fmt.Fprintf(w, " must_have_one_noun+=(%q)\n", value); err != nil { + return err + } + } + return nil +} + +func writeArgAliases(cmd *Command, w io.Writer) error { + if _, err := fmt.Fprintf(w, " noun_aliases=()\n"); err != nil { + return err + } + sort.Sort(sort.StringSlice(cmd.ArgAliases)) + for _, value := range cmd.ArgAliases { + if _, err := fmt.Fprintf(w, " noun_aliases+=(%q)\n", value); err != nil { + return err + } + } + return nil +} + +func gen(cmd *Command, w io.Writer) error { + for _, c := range cmd.Commands() { + if !c.IsAvailableCommand() || c == cmd.helpCommand { + continue + } + if err := gen(c, w); err != nil { + return err + } + } + commandName := cmd.CommandPath() + commandName = strings.Replace(commandName, " ", "_", -1) + commandName = strings.Replace(commandName, ":", "__", -1) + if _, err := fmt.Fprintf(w, "_%s()\n{\n", commandName); err != nil { + return err + } + if _, err := fmt.Fprintf(w, " last_command=%q\n", commandName); err != nil { + return err + } + if err := writeCommands(cmd, w); err != nil { + return err + } + if err := writeFlags(cmd, w); err != nil { + return err + } + if err := writeRequiredFlag(cmd, w); err != nil { + return err + } + if err := writeRequiredNouns(cmd, w); err != nil { + return err + } + if err := writeArgAliases(cmd, w); err != nil { + return err + } + if _, err := fmt.Fprintf(w, "}\n\n"); err != nil { + return err + } + return nil +} + +func (cmd *Command) GenBashCompletion(w io.Writer) error { + if err := preamble(w, cmd.Name()); err != nil { + return err + } + if len(cmd.BashCompletionFunction) > 0 { + if _, err := fmt.Fprintf(w, "%s\n", cmd.BashCompletionFunction); err != nil { + return err + } + } + if err := gen(cmd, w); err != nil { + return err + } + return postscript(w, cmd.Name()) +} + +func (cmd *Command) GenBashCompletionFile(filename string) error { + outFile, err := os.Create(filename) + if err != nil { + return err + } + defer outFile.Close() + + return cmd.GenBashCompletion(outFile) +} + +// MarkFlagRequired adds the BashCompOneRequiredFlag annotation to the named flag, if it exists. +func (cmd *Command) MarkFlagRequired(name string) error { + return MarkFlagRequired(cmd.Flags(), name) +} + +// MarkPersistentFlagRequired adds the BashCompOneRequiredFlag annotation to the named persistent flag, if it exists. +func (cmd *Command) MarkPersistentFlagRequired(name string) error { + return MarkFlagRequired(cmd.PersistentFlags(), name) +} + +// MarkFlagRequired adds the BashCompOneRequiredFlag annotation to the named flag in the flag set, if it exists. +func MarkFlagRequired(flags *pflag.FlagSet, name string) error { + return flags.SetAnnotation(name, BashCompOneRequiredFlag, []string{"true"}) +} + +// MarkFlagFilename adds the BashCompFilenameExt annotation to the named flag, if it exists. +// Generated bash autocompletion will select filenames for the flag, limiting to named extensions if provided. +func (cmd *Command) MarkFlagFilename(name string, extensions ...string) error { + return MarkFlagFilename(cmd.Flags(), name, extensions...) +} + +// MarkFlagCustom adds the BashCompCustom annotation to the named flag, if it exists. +// Generated bash autocompletion will call the bash function f for the flag. +func (cmd *Command) MarkFlagCustom(name string, f string) error { + return MarkFlagCustom(cmd.Flags(), name, f) +} + +// MarkPersistentFlagFilename adds the BashCompFilenameExt annotation to the named persistent flag, if it exists. +// Generated bash autocompletion will select filenames for the flag, limiting to named extensions if provided. +func (cmd *Command) MarkPersistentFlagFilename(name string, extensions ...string) error { + return MarkFlagFilename(cmd.PersistentFlags(), name, extensions...) +} + +// MarkFlagFilename adds the BashCompFilenameExt annotation to the named flag in the flag set, if it exists. +// Generated bash autocompletion will select filenames for the flag, limiting to named extensions if provided. +func MarkFlagFilename(flags *pflag.FlagSet, name string, extensions ...string) error { + return flags.SetAnnotation(name, BashCompFilenameExt, extensions) +} + +// MarkFlagCustom adds the BashCompCustom annotation to the named flag in the flag set, if it exists. +// Generated bash autocompletion will call the bash function f for the flag. +func MarkFlagCustom(flags *pflag.FlagSet, name string, f string) error { + return flags.SetAnnotation(name, BashCompCustom, []string{f}) +} diff --git a/vendor/github.com/spf13/cobra/bash_completions.md b/vendor/github.com/spf13/cobra/bash_completions.md new file mode 100644 index 000000000..84d5b012f --- /dev/null +++ b/vendor/github.com/spf13/cobra/bash_completions.md @@ -0,0 +1,206 @@ +# Generating Bash Completions For Your Own cobra.Command + +Generating bash completions from a cobra command is incredibly easy. An actual program which does so for the kubernetes kubectl binary is as follows: + +```go +package main + +import ( + "io/ioutil" + "os" + + "github.com/GoogleCloudPlatform/kubernetes/pkg/kubectl/cmd" +) + +func main() { + kubectl := cmd.NewFactory(nil).NewKubectlCommand(os.Stdin, ioutil.Discard, ioutil.Discard) + kubectl.GenBashCompletionFile("out.sh") +} +``` + +That will get you completions of subcommands and flags. If you make additional annotations to your code, you can get even more intelligent and flexible behavior. + +## Creating your own custom functions + +Some more actual code that works in kubernetes: + +```bash +const ( + bash_completion_func = `__kubectl_parse_get() +{ + local kubectl_output out + if kubectl_output=$(kubectl get --no-headers "$1" 2>/dev/null); then + out=($(echo "${kubectl_output}" | awk '{print $1}')) + COMPREPLY=( $( compgen -W "${out[*]}" -- "$cur" ) ) + fi +} + +__kubectl_get_resource() +{ + if [[ ${#nouns[@]} -eq 0 ]]; then + return 1 + fi + __kubectl_parse_get ${nouns[${#nouns[@]} -1]} + if [[ $? -eq 0 ]]; then + return 0 + fi +} + +__custom_func() { + case ${last_command} in + kubectl_get | kubectl_describe | kubectl_delete | kubectl_stop) + __kubectl_get_resource + return + ;; + *) + ;; + esac +} +`) +``` + +And then I set that in my command definition: + +```go +cmds := &cobra.Command{ + Use: "kubectl", + Short: "kubectl controls the Kubernetes cluster manager", + Long: `kubectl controls the Kubernetes cluster manager. + +Find more information at https://github.com/GoogleCloudPlatform/kubernetes.`, + Run: runHelp, + BashCompletionFunction: bash_completion_func, +} +``` + +The `BashCompletionFunction` option is really only valid/useful on the root command. Doing the above will cause `__custom_func()` to be called when the built in processor was unable to find a solution. In the case of kubernetes a valid command might look something like `kubectl get pod [mypod]`. If you type `kubectl get pod [tab][tab]` the `__customc_func()` will run because the cobra.Command only understood "kubectl" and "get." `__custom_func()` will see that the cobra.Command is "kubectl_get" and will thus call another helper `__kubectl_get_resource()`. `__kubectl_get_resource` will look at the 'nouns' collected. In our example the only noun will be `pod`. So it will call `__kubectl_parse_get pod`. `__kubectl_parse_get` will actually call out to kubernetes and get any pods. It will then set `COMPREPLY` to valid pods! + +## Have the completions code complete your 'nouns' + +In the above example "pod" was assumed to already be typed. But if you want `kubectl get [tab][tab]` to show a list of valid "nouns" you have to set them. Simplified code from `kubectl get` looks like: + +```go +validArgs []string = { "pod", "node", "service", "replicationcontroller" } + +cmd := &cobra.Command{ + Use: "get [(-o|--output=)json|yaml|template|...] (RESOURCE [NAME] | RESOURCE/NAME ...)", + Short: "Display one or many resources", + Long: get_long, + Example: get_example, + Run: func(cmd *cobra.Command, args []string) { + err := RunGet(f, out, cmd, args) + util.CheckErr(err) + }, + ValidArgs: validArgs, +} +``` + +Notice we put the "ValidArgs" on the "get" subcommand. Doing so will give results like + +```bash +# kubectl get [tab][tab] +node pod replicationcontroller service +``` + +## Plural form and shortcuts for nouns + +If your nouns have a number of aliases, you can define them alongside `ValidArgs` using `ArgAliases`: + +```go` +argAliases []string = { "pods", "nodes", "services", "svc", "replicationcontrollers", "rc" } + +cmd := &cobra.Command{ + ... + ValidArgs: validArgs, + ArgAliases: argAliases +} +``` + +The aliases are not shown to the user on tab completion, but they are accepted as valid nouns by +the completion aglorithm if entered manually, e.g. in: + +```bash +# kubectl get rc [tab][tab] +backend frontend database +``` + +Note that without declaring `rc` as an alias, the completion algorithm would show the list of nouns +in this example again instead of the replication controllers. + +## Mark flags as required + +Most of the time completions will only show subcommands. But if a flag is required to make a subcommand work, you probably want it to show up when the user types [tab][tab]. Marking a flag as 'Required' is incredibly easy. + +```go +cmd.MarkFlagRequired("pod") +cmd.MarkFlagRequired("container") +``` + +and you'll get something like + +```bash +# kubectl exec [tab][tab][tab] +-c --container= -p --pod= +``` + +# Specify valid filename extensions for flags that take a filename + +In this example we use --filename= and expect to get a json or yaml file as the argument. To make this easier we annotate the --filename flag with valid filename extensions. + +```go + annotations := []string{"json", "yaml", "yml"} + annotation := make(map[string][]string) + annotation[cobra.BashCompFilenameExt] = annotations + + flag := &pflag.Flag{ + Name: "filename", + Shorthand: "f", + Usage: usage, + Value: value, + DefValue: value.String(), + Annotations: annotation, + } + cmd.Flags().AddFlag(flag) +``` + +Now when you run a command with this filename flag you'll get something like + +```bash +# kubectl create -f +test/ example/ rpmbuild/ +hello.yml test.json +``` + +So while there are many other files in the CWD it only shows me subdirs and those with valid extensions. + +# Specifiy custom flag completion + +Similar to the filename completion and filtering usingn cobra.BashCompFilenameExt, you can specifiy +a custom flag completion function with cobra.BashCompCustom: + +```go + annotation := make(map[string][]string) + annotation[cobra.BashCompFilenameExt] = []string{"__kubectl_get_namespaces"} + + flag := &pflag.Flag{ + Name: "namespace", + Usage: usage, + Annotations: annotation, + } + cmd.Flags().AddFlag(flag) +``` + +In addition add the `__handle_namespace_flag` implementation in the `BashCompletionFunction` +value, e.g.: + +```bash +__kubectl_get_namespaces() +{ + local template + template="{{ range .items }}{{ .metadata.name }} {{ end }}" + local kubectl_out + if kubectl_out=$(kubectl get -o template --template="${template}" namespace 2>/dev/null); then + COMPREPLY=( $( compgen -W "${kubectl_out}[*]" -- "$cur" ) ) + fi +} +``` diff --git a/vendor/github.com/spf13/cobra/bash_completions_test.go b/vendor/github.com/spf13/cobra/bash_completions_test.go new file mode 100644 index 000000000..6957f8bd8 --- /dev/null +++ b/vendor/github.com/spf13/cobra/bash_completions_test.go @@ -0,0 +1,140 @@ +package cobra + +import ( + "bytes" + "fmt" + "os" + "os/exec" + "strings" + "testing" +) + +var _ = fmt.Println +var _ = os.Stderr + +func checkOmit(t *testing.T, found, unexpected string) { + if strings.Contains(found, unexpected) { + t.Errorf("Unexpected response.\nGot: %q\nBut should not have!\n", unexpected) + } +} + +func check(t *testing.T, found, expected string) { + if !strings.Contains(found, expected) { + t.Errorf("Unexpected response.\nExpecting to contain: \n %q\nGot:\n %q\n", expected, found) + } +} + +func runShellCheck(s string) error { + excluded := []string{ + "SC2034", // PREFIX appears unused. Verify it or export it. + } + cmd := exec.Command("shellcheck", "-s", "bash", "-", "-e", strings.Join(excluded, ",")) + cmd.Stderr = os.Stderr + cmd.Stdout = os.Stdout + + stdin, err := cmd.StdinPipe() + if err != nil { + return err + } + go func() { + defer stdin.Close() + stdin.Write([]byte(s)) + }() + + return cmd.Run() +} + +// World worst custom function, just keep telling you to enter hello! +const ( + bashCompletionFunc = `__custom_func() { +COMPREPLY=( "hello" ) +} +` +) + +func TestBashCompletions(t *testing.T) { + c := initializeWithRootCmd() + cmdEcho.AddCommand(cmdTimes) + c.AddCommand(cmdEcho, cmdPrint, cmdDeprecated, cmdColon) + + // custom completion function + c.BashCompletionFunction = bashCompletionFunc + + // required flag + c.MarkFlagRequired("introot") + + // valid nouns + validArgs := []string{"pod", "node", "service", "replicationcontroller"} + c.ValidArgs = validArgs + + // noun aliases + argAliases := []string{"pods", "nodes", "services", "replicationcontrollers", "po", "no", "svc", "rc"} + c.ArgAliases = argAliases + + // filename + var flagval string + c.Flags().StringVar(&flagval, "filename", "", "Enter a filename") + c.MarkFlagFilename("filename", "json", "yaml", "yml") + + // persistent filename + var flagvalPersistent string + c.PersistentFlags().StringVar(&flagvalPersistent, "persistent-filename", "", "Enter a filename") + c.MarkPersistentFlagFilename("persistent-filename") + c.MarkPersistentFlagRequired("persistent-filename") + + // filename extensions + var flagvalExt string + c.Flags().StringVar(&flagvalExt, "filename-ext", "", "Enter a filename (extension limited)") + c.MarkFlagFilename("filename-ext") + + // filename extensions + var flagvalCustom string + c.Flags().StringVar(&flagvalCustom, "custom", "", "Enter a filename (extension limited)") + c.MarkFlagCustom("custom", "__complete_custom") + + // subdirectories in a given directory + var flagvalTheme string + c.Flags().StringVar(&flagvalTheme, "theme", "", "theme to use (located in /themes/THEMENAME/)") + c.Flags().SetAnnotation("theme", BashCompSubdirsInDir, []string{"themes"}) + + out := new(bytes.Buffer) + c.GenBashCompletion(out) + str := out.String() + + check(t, str, "_cobra-test") + check(t, str, "_cobra-test_echo") + check(t, str, "_cobra-test_echo_times") + check(t, str, "_cobra-test_print") + check(t, str, "_cobra-test_cmd__colon") + + // check for required flags + check(t, str, `must_have_one_flag+=("--introot=")`) + check(t, str, `must_have_one_flag+=("--persistent-filename=")`) + // check for custom completion function + check(t, str, `COMPREPLY=( "hello" )`) + // check for required nouns + check(t, str, `must_have_one_noun+=("pod")`) + // check for noun aliases + check(t, str, `noun_aliases+=("pods")`) + check(t, str, `noun_aliases+=("rc")`) + checkOmit(t, str, `must_have_one_noun+=("pods")`) + // check for filename extension flags + check(t, str, `flags_completion+=("_filedir")`) + // check for filename extension flags + check(t, str, `flags_completion+=("__handle_filename_extension_flag json|yaml|yml")`) + // check for custom flags + check(t, str, `flags_completion+=("__complete_custom")`) + // check for subdirs_in_dir flags + check(t, str, `flags_completion+=("__handle_subdirs_in_dir_flag themes")`) + + checkOmit(t, str, cmdDeprecated.Name()) + + // if available, run shellcheck against the script + if err := exec.Command("which", "shellcheck").Run(); err != nil { + return + } + err := runShellCheck(str) + if err != nil { + t.Fatalf("shellcheck failed: %v", err) + } +} diff --git a/vendor/github.com/spf13/cobra/cobra.go b/vendor/github.com/spf13/cobra/cobra.go new file mode 100644 index 000000000..0c4e2e5de --- /dev/null +++ b/vendor/github.com/spf13/cobra/cobra.go @@ -0,0 +1,171 @@ +// Copyright © 2013 Steve Francia . +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Commands similar to git, go tools and other modern CLI tools +// inspired by go, go-Commander, gh and subcommand + +package cobra + +import ( + "fmt" + "io" + "reflect" + "strconv" + "strings" + "text/template" + "unicode" +) + +var templateFuncs = template.FuncMap{ + "trim": strings.TrimSpace, + "trimRightSpace": trimRightSpace, + "appendIfNotPresent": appendIfNotPresent, + "rpad": rpad, + "gt": Gt, + "eq": Eq, +} + +var initializers []func() + +// automatic prefix matching can be a dangerous thing to automatically enable in CLI tools. +// Set this to true to enable it +var EnablePrefixMatching = false + +//AddTemplateFunc adds a template function that's available to Usage and Help +//template generation. +func AddTemplateFunc(name string, tmplFunc interface{}) { + templateFuncs[name] = tmplFunc +} + +//AddTemplateFuncs adds multiple template functions availalble to Usage and +//Help template generation. +func AddTemplateFuncs(tmplFuncs template.FuncMap) { + for k, v := range tmplFuncs { + templateFuncs[k] = v + } +} + +//OnInitialize takes a series of func() arguments and appends them to a slice of func(). +func OnInitialize(y ...func()) { + for _, x := range y { + initializers = append(initializers, x) + } +} + +//Gt takes two types and checks whether the first type is greater than the second. In case of types Arrays, Chans, +//Maps and Slices, Gt will compare their lengths. Ints are compared directly while strings are first parsed as +//ints and then compared. +func Gt(a interface{}, b interface{}) bool { + var left, right int64 + av := reflect.ValueOf(a) + + switch av.Kind() { + case reflect.Array, reflect.Chan, reflect.Map, reflect.Slice: + left = int64(av.Len()) + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + left = av.Int() + case reflect.String: + left, _ = strconv.ParseInt(av.String(), 10, 64) + } + + bv := reflect.ValueOf(b) + + switch bv.Kind() { + case reflect.Array, reflect.Chan, reflect.Map, reflect.Slice: + right = int64(bv.Len()) + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + right = bv.Int() + case reflect.String: + right, _ = strconv.ParseInt(bv.String(), 10, 64) + } + + return left > right +} + +//Eq takes two types and checks whether they are equal. Supported types are int and string. Unsupported types will panic. +func Eq(a interface{}, b interface{}) bool { + av := reflect.ValueOf(a) + bv := reflect.ValueOf(b) + + switch av.Kind() { + case reflect.Array, reflect.Chan, reflect.Map, reflect.Slice: + panic("Eq called on unsupported type") + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + return av.Int() == bv.Int() + case reflect.String: + return av.String() == bv.String() + } + return false +} + +func trimRightSpace(s string) string { + return strings.TrimRightFunc(s, unicode.IsSpace) +} + +// appendIfNotPresent will append stringToAppend to the end of s, but only if it's not yet present in s +func appendIfNotPresent(s, stringToAppend string) string { + if strings.Contains(s, stringToAppend) { + return s + } + return s + " " + stringToAppend +} + +//rpad adds padding to the right of a string +func rpad(s string, padding int) string { + template := fmt.Sprintf("%%-%ds", padding) + return fmt.Sprintf(template, s) +} + +// tmpl executes the given template text on data, writing the result to w. +func tmpl(w io.Writer, text string, data interface{}) error { + t := template.New("top") + t.Funcs(templateFuncs) + template.Must(t.Parse(text)) + return t.Execute(w, data) +} + +// ld compares two strings and returns the levenshtein distance between them +func ld(s, t string, ignoreCase bool) int { + if ignoreCase { + s = strings.ToLower(s) + t = strings.ToLower(t) + } + d := make([][]int, len(s)+1) + for i := range d { + d[i] = make([]int, len(t)+1) + } + for i := range d { + d[i][0] = i + } + for j := range d[0] { + d[0][j] = j + } + for j := 1; j <= len(t); j++ { + for i := 1; i <= len(s); i++ { + if s[i-1] == t[j-1] { + d[i][j] = d[i-1][j-1] + } else { + min := d[i-1][j] + if d[i][j-1] < min { + min = d[i][j-1] + } + if d[i-1][j-1] < min { + min = d[i-1][j-1] + } + d[i][j] = min + 1 + } + } + + } + return d[len(s)][len(t)] +} diff --git a/vendor/github.com/spf13/cobra/cobra_test.go b/vendor/github.com/spf13/cobra/cobra_test.go new file mode 100644 index 000000000..97090b107 --- /dev/null +++ b/vendor/github.com/spf13/cobra/cobra_test.go @@ -0,0 +1,1188 @@ +package cobra + +import ( + "bytes" + "fmt" + "os" + "reflect" + "runtime" + "strings" + "testing" + "text/template" + + "github.com/spf13/pflag" +) + +var _ = fmt.Println +var _ = os.Stderr + +var tp, te, tt, t1, tr []string +var rootPersPre, echoPre, echoPersPre, timesPersPre []string +var flagb1, flagb2, flagb3, flagbr, flagbp bool +var flags1, flags2a, flags2b, flags3, outs string +var flagi1, flagi2, flagi3, flagi4, flagir int +var globalFlag1 bool +var flagEcho, rootcalled bool +var versionUsed int + +const strtwoParentHelp = "help message for parent flag strtwo" +const strtwoChildHelp = "help message for child flag strtwo" + +var cmdHidden = &Command{ + Use: "hide [secret string to print]", + Short: "Print anything to screen (if command is known)", + Long: `an absolutely utterly useless command for testing.`, + Run: func(cmd *Command, args []string) { + outs = "hidden" + }, + Hidden: true, +} + +var cmdPrint = &Command{ + Use: "print [string to print]", + Short: "Print anything to the screen", + Long: `an absolutely utterly useless command for testing.`, + Run: func(cmd *Command, args []string) { + tp = args + }, +} + +var cmdEcho = &Command{ + Use: "echo [string to echo]", + Aliases: []string{"say"}, + Short: "Echo anything to the screen", + Long: `an utterly useless command for testing.`, + Example: "Just run cobra-test echo", + PersistentPreRun: func(cmd *Command, args []string) { + echoPersPre = args + }, + PreRun: func(cmd *Command, args []string) { + echoPre = args + }, + Run: func(cmd *Command, args []string) { + te = args + }, +} + +var cmdEchoSub = &Command{ + Use: "echosub [string to print]", + Short: "second sub command for echo", + Long: `an absolutely utterly useless command for testing gendocs!.`, + Run: func(cmd *Command, args []string) { + }, +} + +var cmdDeprecated = &Command{ + Use: "deprecated [can't do anything here]", + Short: "A command which is deprecated", + Long: `an absolutely utterly useless command for testing deprecation!.`, + Deprecated: "Please use echo instead", + Run: func(cmd *Command, args []string) { + }, +} + +var cmdTimes = &Command{ + Use: "times [# times] [string to echo]", + SuggestFor: []string{"counts"}, + Short: "Echo anything to the screen more times", + Long: `a slightly useless command for testing.`, + PersistentPreRun: func(cmd *Command, args []string) { + timesPersPre = args + }, + Run: func(cmd *Command, args []string) { + tt = args + }, +} + +var cmdRootNoRun = &Command{ + Use: "cobra-test", + Short: "The root can run its own function", + Long: "The root description for help", + PersistentPreRun: func(cmd *Command, args []string) { + rootPersPre = args + }, +} + +var cmdRootSameName = &Command{ + Use: "print", + Short: "Root with the same name as a subcommand", + Long: "The root description for help", +} + +var cmdRootWithRun = &Command{ + Use: "cobra-test", + Short: "The root can run its own function", + Long: "The root description for help", + Run: func(cmd *Command, args []string) { + tr = args + rootcalled = true + }, +} + +var cmdSubNoRun = &Command{ + Use: "subnorun", + Short: "A subcommand without a Run function", + Long: "A long output about a subcommand without a Run function", +} + +var cmdCustomFlags = &Command{ + Use: "customflags [flags] -- REMOTE_COMMAND", + Short: "A command that expects flags in a custom location", + Long: "A long output about a command that expects flags in a custom location", + Run: func(cmd *Command, args []string) { + }, +} + +var cmdVersion1 = &Command{ + Use: "version", + Short: "Print the version number", + Long: `First version of the version command`, + Run: func(cmd *Command, args []string) { + versionUsed = 1 + }, +} + +var cmdVersion2 = &Command{ + Use: "version", + Short: "Print the version number", + Long: `Second version of the version command`, + Run: func(cmd *Command, args []string) { + versionUsed = 2 + }, +} + +var cmdColon = &Command{ + Use: "cmd:colon", + Run: func(cmd *Command, args []string) { + }, +} + +func flagInit() { + cmdEcho.ResetFlags() + cmdPrint.ResetFlags() + cmdTimes.ResetFlags() + cmdRootNoRun.ResetFlags() + cmdRootSameName.ResetFlags() + cmdRootWithRun.ResetFlags() + cmdSubNoRun.ResetFlags() + cmdCustomFlags.ResetFlags() + cmdRootNoRun.PersistentFlags().StringVarP(&flags2a, "strtwo", "t", "two", strtwoParentHelp) + cmdEcho.Flags().IntVarP(&flagi1, "intone", "i", 123, "help message for flag intone") + cmdTimes.Flags().IntVarP(&flagi2, "inttwo", "j", 234, "help message for flag inttwo") + cmdPrint.Flags().IntVarP(&flagi3, "intthree", "i", 345, "help message for flag intthree") + cmdCustomFlags.Flags().IntVar(&flagi4, "intfour", 456, "help message for flag intfour") + cmdEcho.PersistentFlags().StringVarP(&flags1, "strone", "s", "one", "help message for flag strone") + cmdEcho.PersistentFlags().BoolVarP(&flagbp, "persistentbool", "p", false, "help message for flag persistentbool") + cmdTimes.PersistentFlags().StringVarP(&flags2b, "strtwo", "t", "2", strtwoChildHelp) + cmdPrint.PersistentFlags().StringVarP(&flags3, "strthree", "s", "three", "help message for flag strthree") + cmdEcho.Flags().BoolVarP(&flagb1, "boolone", "b", true, "help message for flag boolone") + cmdTimes.Flags().BoolVarP(&flagb2, "booltwo", "c", false, "help message for flag booltwo") + cmdPrint.Flags().BoolVarP(&flagb3, "boolthree", "b", true, "help message for flag boolthree") + cmdVersion1.ResetFlags() + cmdVersion2.ResetFlags() +} + +func commandInit() { + cmdEcho.ResetCommands() + cmdPrint.ResetCommands() + cmdTimes.ResetCommands() + cmdRootNoRun.ResetCommands() + cmdRootSameName.ResetCommands() + cmdRootWithRun.ResetCommands() + cmdSubNoRun.ResetCommands() + cmdCustomFlags.ResetCommands() +} + +func initialize() *Command { + tt, tp, te = nil, nil, nil + rootPersPre, echoPre, echoPersPre, timesPersPre = nil, nil, nil, nil + + var c = cmdRootNoRun + flagInit() + commandInit() + return c +} + +func initializeWithSameName() *Command { + tt, tp, te = nil, nil, nil + rootPersPre, echoPre, echoPersPre, timesPersPre = nil, nil, nil, nil + var c = cmdRootSameName + flagInit() + commandInit() + return c +} + +func initializeWithRootCmd() *Command { + cmdRootWithRun.ResetCommands() + tt, tp, te, tr, rootcalled = nil, nil, nil, nil, false + flagInit() + cmdRootWithRun.Flags().BoolVarP(&flagbr, "boolroot", "b", false, "help message for flag boolroot") + cmdRootWithRun.Flags().IntVarP(&flagir, "introot", "i", 321, "help message for flag introot") + commandInit() + return cmdRootWithRun +} + +type resulter struct { + Error error + Output string + Command *Command +} + +func fullSetupTest(input string) resulter { + c := initializeWithRootCmd() + + return fullTester(c, input) +} + +func noRRSetupTestSilenced(input string) resulter { + c := initialize() + c.SilenceErrors = true + c.SilenceUsage = true + return fullTester(c, input) +} + +func noRRSetupTest(input string) resulter { + c := initialize() + + return fullTester(c, input) +} + +func rootOnlySetupTest(input string) resulter { + c := initializeWithRootCmd() + + return simpleTester(c, input) +} + +func simpleTester(c *Command, input string) resulter { + buf := new(bytes.Buffer) + // Testing flag with invalid input + c.SetOutput(buf) + c.SetArgs(strings.Split(input, " ")) + + err := c.Execute() + output := buf.String() + + return resulter{err, output, c} +} + +func simpleTesterC(c *Command, input string) resulter { + buf := new(bytes.Buffer) + // Testing flag with invalid input + c.SetOutput(buf) + c.SetArgs(strings.Split(input, " ")) + + cmd, err := c.ExecuteC() + output := buf.String() + + return resulter{err, output, cmd} +} + +func fullTester(c *Command, input string) resulter { + buf := new(bytes.Buffer) + // Testing flag with invalid input + c.SetOutput(buf) + cmdEcho.AddCommand(cmdTimes) + c.AddCommand(cmdPrint, cmdEcho, cmdSubNoRun, cmdCustomFlags, cmdDeprecated) + c.SetArgs(strings.Split(input, " ")) + + err := c.Execute() + output := buf.String() + + return resulter{err, output, c} +} + +func logErr(t *testing.T, found, expected string) { + out := new(bytes.Buffer) + + _, _, line, ok := runtime.Caller(2) + if ok { + fmt.Fprintf(out, "Line: %d ", line) + } + fmt.Fprintf(out, "Unexpected response.\nExpecting to contain: \n %q\nGot:\n %q\n", expected, found) + t.Errorf(out.String()) +} + +func checkStringContains(t *testing.T, found, expected string) { + if !strings.Contains(found, expected) { + logErr(t, found, expected) + } +} + +func checkResultContains(t *testing.T, x resulter, check string) { + checkStringContains(t, x.Output, check) +} + +func checkStringOmits(t *testing.T, found, expected string) { + if strings.Contains(found, expected) { + logErr(t, found, expected) + } +} + +func checkResultOmits(t *testing.T, x resulter, check string) { + checkStringOmits(t, x.Output, check) +} + +func checkOutputContains(t *testing.T, c *Command, check string) { + buf := new(bytes.Buffer) + c.SetOutput(buf) + c.Execute() + + if !strings.Contains(buf.String(), check) { + logErr(t, buf.String(), check) + } +} + +func TestSingleCommand(t *testing.T) { + noRRSetupTest("print one two") + + if te != nil || tt != nil { + t.Error("Wrong command called") + } + if tp == nil { + t.Error("Wrong command called") + } + if strings.Join(tp, " ") != "one two" { + t.Error("Command didn't parse correctly") + } +} + +func TestChildCommand(t *testing.T) { + noRRSetupTest("echo times one two") + + if te != nil || tp != nil { + t.Error("Wrong command called") + } + if tt == nil { + t.Error("Wrong command called") + } + if strings.Join(tt, " ") != "one two" { + t.Error("Command didn't parse correctly") + } +} + +func TestCommandAlias(t *testing.T) { + noRRSetupTest("say times one two") + + if te != nil || tp != nil { + t.Error("Wrong command called") + } + if tt == nil { + t.Error("Wrong command called") + } + if strings.Join(tt, " ") != "one two" { + t.Error("Command didn't parse correctly") + } +} + +func TestPrefixMatching(t *testing.T) { + EnablePrefixMatching = true + noRRSetupTest("ech times one two") + + if te != nil || tp != nil { + t.Error("Wrong command called") + } + if tt == nil { + t.Error("Wrong command called") + } + if strings.Join(tt, " ") != "one two" { + t.Error("Command didn't parse correctly") + } + + EnablePrefixMatching = false +} + +func TestNoPrefixMatching(t *testing.T) { + EnablePrefixMatching = false + + noRRSetupTest("ech times one two") + + if !(tt == nil && te == nil && tp == nil) { + t.Error("Wrong command called") + } +} + +func TestAliasPrefixMatching(t *testing.T) { + EnablePrefixMatching = true + noRRSetupTest("sa times one two") + + if te != nil || tp != nil { + t.Error("Wrong command called") + } + if tt == nil { + t.Error("Wrong command called") + } + if strings.Join(tt, " ") != "one two" { + t.Error("Command didn't parse correctly") + } + EnablePrefixMatching = false +} + +func TestChildSameName(t *testing.T) { + c := initializeWithSameName() + c.AddCommand(cmdPrint, cmdEcho) + c.SetArgs(strings.Split("print one two", " ")) + c.Execute() + + if te != nil || tt != nil { + t.Error("Wrong command called") + } + if tp == nil { + t.Error("Wrong command called") + } + if strings.Join(tp, " ") != "one two" { + t.Error("Command didn't parse correctly") + } +} + +func TestGrandChildSameName(t *testing.T) { + c := initializeWithSameName() + cmdTimes.AddCommand(cmdPrint) + c.AddCommand(cmdTimes) + c.SetArgs(strings.Split("times print one two", " ")) + c.Execute() + + if te != nil || tt != nil { + t.Error("Wrong command called") + } + if tp == nil { + t.Error("Wrong command called") + } + if strings.Join(tp, " ") != "one two" { + t.Error("Command didn't parse correctly") + } +} + +func TestUsage(t *testing.T) { + x := fullSetupTest("help") + checkResultContains(t, x, cmdRootWithRun.Use+" [flags]") + x = fullSetupTest("help customflags") + checkResultContains(t, x, cmdCustomFlags.Use) + checkResultOmits(t, x, cmdCustomFlags.Use+" [flags]") +} + +func TestFlagLong(t *testing.T) { + noRRSetupTest("echo --intone=13 something -- here") + + if cmdEcho.ArgsLenAtDash() != 1 { + t.Errorf("expected argsLenAtDash: %d but got %d", 1, cmdRootNoRun.ArgsLenAtDash()) + } + if strings.Join(te, " ") != "something here" { + t.Errorf("flags didn't leave proper args remaining..%s given", te) + } + if flagi1 != 13 { + t.Errorf("int flag didn't get correct value, had %d", flagi1) + } + if flagi2 != 234 { + t.Errorf("default flag value changed, 234 expected, %d given", flagi2) + } +} + +func TestFlagShort(t *testing.T) { + noRRSetupTest("echo -i13 -- something here") + + if cmdEcho.ArgsLenAtDash() != 0 { + t.Errorf("expected argsLenAtDash: %d but got %d", 0, cmdRootNoRun.ArgsLenAtDash()) + } + if strings.Join(te, " ") != "something here" { + t.Errorf("flags didn't leave proper args remaining..%s given", te) + } + if flagi1 != 13 { + t.Errorf("int flag didn't get correct value, had %d", flagi1) + } + if flagi2 != 234 { + t.Errorf("default flag value changed, 234 expected, %d given", flagi2) + } + + noRRSetupTest("echo -i 13 something here") + + if strings.Join(te, " ") != "something here" { + t.Errorf("flags didn't leave proper args remaining..%s given", te) + } + if flagi1 != 13 { + t.Errorf("int flag didn't get correct value, had %d", flagi1) + } + if flagi2 != 234 { + t.Errorf("default flag value changed, 234 expected, %d given", flagi2) + } + + noRRSetupTest("print -i99 one two") + + if strings.Join(tp, " ") != "one two" { + t.Errorf("flags didn't leave proper args remaining..%s given", tp) + } + if flagi3 != 99 { + t.Errorf("int flag didn't get correct value, had %d", flagi3) + } + if flagi1 != 123 { + t.Errorf("default flag value changed on different command with same shortname, 234 expected, %d given", flagi2) + } +} + +func TestChildCommandFlags(t *testing.T) { + noRRSetupTest("echo times -j 99 one two") + + if strings.Join(tt, " ") != "one two" { + t.Errorf("flags didn't leave proper args remaining..%s given", tt) + } + + // Testing with flag that shouldn't be persistent + r := noRRSetupTest("echo times -j 99 -i77 one two") + + if r.Error == nil { + t.Errorf("invalid flag should generate error") + } + + if !strings.Contains(r.Error.Error(), "unknown shorthand") { + t.Errorf("Wrong error message displayed, \n %s", r.Error) + } + + if flagi2 != 99 { + t.Errorf("flag value should be 99, %d given", flagi2) + } + + if flagi1 != 123 { + t.Errorf("unset flag should have default value, expecting 123, given %d", flagi1) + } + + // Testing with flag only existing on child + r = noRRSetupTest("echo -j 99 -i77 one two") + + if r.Error == nil { + t.Errorf("invalid flag should generate error") + } + if !strings.Contains(r.Error.Error(), "unknown shorthand flag") { + t.Errorf("Wrong error message displayed, \n %s", r.Error) + } + + // Testing with persistent flag overwritten by child + noRRSetupTest("echo times --strtwo=child one two") + + if flags2b != "child" { + t.Errorf("flag value should be child, %s given", flags2b) + } + + if flags2a != "two" { + t.Errorf("unset flag should have default value, expecting two, given %s", flags2a) + } + + // Testing flag with invalid input + r = noRRSetupTest("echo -i10E") + + if r.Error == nil { + t.Errorf("invalid input should generate error") + } + if !strings.Contains(r.Error.Error(), "invalid argument \"10E\" for i10E") { + t.Errorf("Wrong error message displayed, \n %s", r.Error) + } +} + +func TestTrailingCommandFlags(t *testing.T) { + x := fullSetupTest("echo two -x") + + if x.Error == nil { + t.Errorf("invalid flag should generate error") + } +} + +func TestInvalidSubcommandFlags(t *testing.T) { + cmd := initializeWithRootCmd() + cmd.AddCommand(cmdTimes) + + result := simpleTester(cmd, "times --inttwo=2 --badflag=bar") + // given that we are not checking here result.Error we check for + // stock usage message + checkResultContains(t, result, "cobra-test times [# times]") + if strings.Contains(result.Error.Error(), "unknown flag: --inttwo") { + t.Errorf("invalid --badflag flag shouldn't fail on 'unknown' --inttwo flag") + } + +} + +func TestSubcommandExecuteC(t *testing.T) { + cmd := initializeWithRootCmd() + double := &Command{ + Use: "double message", + Run: func(c *Command, args []string) { + msg := strings.Join(args, " ") + c.Println(msg, msg) + }, + } + + echo := &Command{ + Use: "echo message", + Run: func(c *Command, args []string) { + msg := strings.Join(args, " ") + c.Println(msg, msg) + }, + } + + cmd.AddCommand(double, echo) + + result := simpleTesterC(cmd, "double hello world") + checkResultContains(t, result, "hello world hello world") + + if result.Command.Name() != "double" { + t.Errorf("invalid cmd returned from ExecuteC: should be 'double' but got %s", result.Command.Name()) + } + + result = simpleTesterC(cmd, "echo msg to be echoed") + checkResultContains(t, result, "msg to be echoed") + + if result.Command.Name() != "echo" { + t.Errorf("invalid cmd returned from ExecuteC: should be 'echo' but got %s", result.Command.Name()) + } +} + +func TestSubcommandArgEvaluation(t *testing.T) { + cmd := initializeWithRootCmd() + + first := &Command{ + Use: "first", + Run: func(cmd *Command, args []string) { + }, + } + cmd.AddCommand(first) + + second := &Command{ + Use: "second", + Run: func(cmd *Command, args []string) { + fmt.Fprintf(cmd.Out(), "%v", args) + }, + } + first.AddCommand(second) + + result := simpleTester(cmd, "first second first third") + + expectedOutput := fmt.Sprintf("%v", []string{"first third"}) + if result.Output != expectedOutput { + t.Errorf("exptected %v, got %v", expectedOutput, result.Output) + } +} + +func TestPersistentFlags(t *testing.T) { + fullSetupTest("echo -s something -p more here") + + // persistentFlag should act like normal flag on its own command + if strings.Join(te, " ") != "more here" { + t.Errorf("flags didn't leave proper args remaining..%s given", te) + } + if flags1 != "something" { + t.Errorf("string flag didn't get correct value, had %v", flags1) + } + if !flagbp { + t.Errorf("persistent bool flag not parsed correctly. Expected true, had %v", flagbp) + } + + // persistentFlag should act like normal flag on its own command + fullSetupTest("echo times -s again -c -p test here") + + if strings.Join(tt, " ") != "test here" { + t.Errorf("flags didn't leave proper args remaining..%s given", tt) + } + + if flags1 != "again" { + t.Errorf("string flag didn't get correct value, had %v", flags1) + } + + if !flagb2 { + t.Errorf("local flag not parsed correctly. Expected true, had %v", flagb2) + } + if !flagbp { + t.Errorf("persistent bool flag not parsed correctly. Expected true, had %v", flagbp) + } +} + +func TestHelpCommand(t *testing.T) { + x := fullSetupTest("help") + checkResultContains(t, x, cmdRootWithRun.Long) + + x = fullSetupTest("help echo") + checkResultContains(t, x, cmdEcho.Long) + + x = fullSetupTest("help echo times") + checkResultContains(t, x, cmdTimes.Long) +} + +func TestChildCommandHelp(t *testing.T) { + c := noRRSetupTest("print --help") + checkResultContains(t, c, strtwoParentHelp) + r := noRRSetupTest("echo times --help") + checkResultContains(t, r, strtwoChildHelp) +} + +func TestNonRunChildHelp(t *testing.T) { + x := noRRSetupTest("subnorun") + checkResultContains(t, x, cmdSubNoRun.Long) +} + +func TestRunnableRootCommand(t *testing.T) { + x := fullSetupTest("") + + if rootcalled != true { + t.Errorf("Root Function was not called\n out:%v", x.Error) + } +} + +func TestVisitParents(t *testing.T) { + c := &Command{Use: "app"} + sub := &Command{Use: "sub"} + dsub := &Command{Use: "dsub"} + sub.AddCommand(dsub) + c.AddCommand(sub) + total := 0 + add := func(x *Command) { + total++ + } + sub.VisitParents(add) + if total != 1 { + t.Errorf("Should have visited 1 parent but visited %d", total) + } + + total = 0 + dsub.VisitParents(add) + if total != 2 { + t.Errorf("Should have visited 2 parent but visited %d", total) + } + + total = 0 + c.VisitParents(add) + if total != 0 { + t.Errorf("Should have not visited any parent but visited %d", total) + } +} + +func TestRunnableRootCommandNilInput(t *testing.T) { + var emptyArg []string + c := initializeWithRootCmd() + + buf := new(bytes.Buffer) + // Testing flag with invalid input + c.SetOutput(buf) + cmdEcho.AddCommand(cmdTimes) + c.AddCommand(cmdPrint, cmdEcho) + c.SetArgs(emptyArg) + + err := c.Execute() + if err != nil { + t.Errorf("Execute() failed with %v", err) + } + + if rootcalled != true { + t.Errorf("Root Function was not called") + } +} + +func TestRunnableRootCommandEmptyInput(t *testing.T) { + args := make([]string, 3) + args[0] = "" + args[1] = "--introot=12" + args[2] = "" + c := initializeWithRootCmd() + + buf := new(bytes.Buffer) + // Testing flag with invalid input + c.SetOutput(buf) + cmdEcho.AddCommand(cmdTimes) + c.AddCommand(cmdPrint, cmdEcho) + c.SetArgs(args) + + c.Execute() + + if rootcalled != true { + t.Errorf("Root Function was not called.\n\nOutput was:\n\n%s\n", buf) + } +} + +func TestInvalidSubcommandWhenArgsAllowed(t *testing.T) { + fullSetupTest("echo invalid-sub") + + if te[0] != "invalid-sub" { + t.Errorf("Subcommand didn't work...") + } +} + +func TestRootFlags(t *testing.T) { + fullSetupTest("-i 17 -b") + + if flagbr != true { + t.Errorf("flag value should be true, %v given", flagbr) + } + + if flagir != 17 { + t.Errorf("flag value should be 17, %d given", flagir) + } +} + +func TestRootHelp(t *testing.T) { + x := fullSetupTest("--help") + + checkResultContains(t, x, "Available Commands:") + checkResultContains(t, x, "for more information about a command") + + if strings.Contains(x.Output, "unknown flag: --help") { + t.Errorf("--help shouldn't trigger an error, Got: \n %s", x.Output) + } + + if strings.Contains(x.Output, cmdEcho.Use) { + t.Errorf("--help shouldn't display subcommand's usage, Got: \n %s", x.Output) + } + + x = fullSetupTest("echo --help") + + if strings.Contains(x.Output, cmdTimes.Use) { + t.Errorf("--help shouldn't display subsubcommand's usage, Got: \n %s", x.Output) + } + + checkResultContains(t, x, "Available Commands:") + checkResultContains(t, x, "for more information about a command") + + if strings.Contains(x.Output, "unknown flag: --help") { + t.Errorf("--help shouldn't trigger an error, Got: \n %s", x.Output) + } + +} + +func TestFlagAccess(t *testing.T) { + initialize() + + local := cmdTimes.LocalFlags() + inherited := cmdTimes.InheritedFlags() + + for _, f := range []string{"inttwo", "strtwo", "booltwo"} { + if local.Lookup(f) == nil { + t.Errorf("LocalFlags expected to contain %s, Got: nil", f) + } + } + if inherited.Lookup("strone") == nil { + t.Errorf("InheritedFlags expected to contain strone, Got: nil") + } + if inherited.Lookup("strtwo") != nil { + t.Errorf("InheritedFlags shouldn not contain overwritten flag strtwo") + + } +} + +func TestNoNRunnableRootCommandNilInput(t *testing.T) { + var args []string + c := initialize() + + buf := new(bytes.Buffer) + // Testing flag with invalid input + c.SetOutput(buf) + cmdEcho.AddCommand(cmdTimes) + c.AddCommand(cmdPrint, cmdEcho) + c.SetArgs(args) + + c.Execute() + + if !strings.Contains(buf.String(), cmdRootNoRun.Long) { + t.Errorf("Expected to get help output, Got: \n %s", buf) + } +} + +func TestRootNoCommandHelp(t *testing.T) { + x := rootOnlySetupTest("--help") + + checkResultOmits(t, x, "Available Commands:") + checkResultOmits(t, x, "for more information about a command") + + if strings.Contains(x.Output, "unknown flag: --help") { + t.Errorf("--help shouldn't trigger an error, Got: \n %s", x.Output) + } + + x = rootOnlySetupTest("echo --help") + + checkResultOmits(t, x, "Available Commands:") + checkResultOmits(t, x, "for more information about a command") + + if strings.Contains(x.Output, "unknown flag: --help") { + t.Errorf("--help shouldn't trigger an error, Got: \n %s", x.Output) + } +} + +func TestRootUnknownCommand(t *testing.T) { + r := noRRSetupTest("bogus") + s := "Error: unknown command \"bogus\" for \"cobra-test\"\nRun 'cobra-test --help' for usage.\n" + + if r.Output != s { + t.Errorf("Unexpected response.\nExpecting to be:\n %q\nGot:\n %q\n", s, r.Output) + } + + r = noRRSetupTest("--strtwo=a bogus") + if r.Output != s { + t.Errorf("Unexpected response.\nExpecting to be:\n %q\nGot:\n %q\n", s, r.Output) + } +} + +func TestRootUnknownCommandSilenced(t *testing.T) { + r := noRRSetupTestSilenced("bogus") + s := "Run 'cobra-test --help' for usage.\n" + + if r.Output != "" { + t.Errorf("Unexpected response.\nExpecting to be: \n\"\"\n Got:\n %q\n", s, r.Output) + } + + r = noRRSetupTestSilenced("--strtwo=a bogus") + if r.Output != "" { + t.Errorf("Unexpected response.\nExpecting to be:\n\"\"\nGot:\n %q\n", s, r.Output) + } +} + +func TestRootSuggestions(t *testing.T) { + outputWithSuggestions := "Error: unknown command \"%s\" for \"cobra-test\"\n\nDid you mean this?\n\t%s\n\nRun 'cobra-test --help' for usage.\n" + outputWithoutSuggestions := "Error: unknown command \"%s\" for \"cobra-test\"\nRun 'cobra-test --help' for usage.\n" + + cmd := initializeWithRootCmd() + cmd.AddCommand(cmdTimes) + + tests := map[string]string{ + "time": "times", + "tiems": "times", + "tims": "times", + "timeS": "times", + "rimes": "times", + "ti": "times", + "t": "times", + "timely": "times", + "ri": "", + "timezone": "", + "foo": "", + "counts": "times", + } + + for typo, suggestion := range tests { + for _, suggestionsDisabled := range []bool{false, true} { + cmd.DisableSuggestions = suggestionsDisabled + result := simpleTester(cmd, typo) + expected := "" + if len(suggestion) == 0 || suggestionsDisabled { + expected = fmt.Sprintf(outputWithoutSuggestions, typo) + } else { + expected = fmt.Sprintf(outputWithSuggestions, typo, suggestion) + } + if result.Output != expected { + t.Errorf("Unexpected response.\nExpecting to be:\n %q\nGot:\n %q\n", expected, result.Output) + } + } + } +} + +func TestFlagsBeforeCommand(t *testing.T) { + // short without space + x := fullSetupTest("-i10 echo") + if x.Error != nil { + t.Errorf("Valid Input shouldn't have errors, got:\n %q", x.Error) + } + + // short (int) with equals + // It appears that pflags doesn't support this... + // Commenting out until support can be added + + //x = noRRSetupTest("echo -i=10") + //if x.Error != nil { + //t.Errorf("Valid Input shouldn't have errors, got:\n %s", x.Error) + //} + + // long with equals + x = noRRSetupTest("--intone=123 echo one two") + if x.Error != nil { + t.Errorf("Valid Input shouldn't have errors, got:\n %s", x.Error) + } + + // With parsing error properly reported + x = fullSetupTest("-i10E echo") + if !strings.Contains(x.Error.Error(), "invalid argument \"10E\" for i10E") { + t.Errorf("Wrong error message displayed, \n %s", x.Error) + } + + //With quotes + x = fullSetupTest("-s=\"walking\" echo") + if x.Error != nil { + t.Errorf("Valid Input shouldn't have errors, got:\n %q", x.Error) + } + + //With quotes and space + x = fullSetupTest("-s=\"walking fast\" echo") + if x.Error != nil { + t.Errorf("Valid Input shouldn't have errors, got:\n %q", x.Error) + } + + //With inner quote + x = fullSetupTest("-s=\"walking \\\"Inner Quote\\\" fast\" echo") + if x.Error != nil { + t.Errorf("Valid Input shouldn't have errors, got:\n %q", x.Error) + } + + //With quotes and space + x = fullSetupTest("-s=\"walking \\\"Inner Quote\\\" fast\" echo") + if x.Error != nil { + t.Errorf("Valid Input shouldn't have errors, got:\n %q", x.Error) + } + +} + +func TestRemoveCommand(t *testing.T) { + versionUsed = 0 + c := initializeWithRootCmd() + c.AddCommand(cmdVersion1) + c.RemoveCommand(cmdVersion1) + x := fullTester(c, "version") + if x.Error == nil { + t.Errorf("Removed command should not have been called\n") + return + } +} + +func TestCommandWithoutSubcommands(t *testing.T) { + c := initializeWithRootCmd() + + x := simpleTester(c, "") + if x.Error != nil { + t.Errorf("Calling command without subcommands should not have error: %v", x.Error) + return + } +} + +func TestCommandWithoutSubcommandsWithArg(t *testing.T) { + c := initializeWithRootCmd() + expectedArgs := []string{"arg"} + + x := simpleTester(c, "arg") + if x.Error != nil { + t.Errorf("Calling command without subcommands but with arg should not have error: %v", x.Error) + return + } + if !reflect.DeepEqual(expectedArgs, tr) { + t.Errorf("Calling command without subcommands but with arg has wrong args: expected: %v, actual: %v", expectedArgs, tr) + return + } +} + +func TestReplaceCommandWithRemove(t *testing.T) { + versionUsed = 0 + c := initializeWithRootCmd() + c.AddCommand(cmdVersion1) + c.RemoveCommand(cmdVersion1) + c.AddCommand(cmdVersion2) + x := fullTester(c, "version") + if x.Error != nil { + t.Errorf("Valid Input shouldn't have errors, got:\n %q", x.Error) + return + } + if versionUsed == 1 { + t.Errorf("Removed command shouldn't be called\n") + } + if versionUsed != 2 { + t.Errorf("Replacing command should have been called but didn't\n") + } +} + +func TestDeprecatedSub(t *testing.T) { + c := fullSetupTest("deprecated") + + checkResultContains(t, c, cmdDeprecated.Deprecated) +} + +func TestPreRun(t *testing.T) { + noRRSetupTest("echo one two") + if echoPre == nil || echoPersPre == nil { + t.Error("PreRun or PersistentPreRun not called") + } + if rootPersPre != nil || timesPersPre != nil { + t.Error("Wrong *Pre functions called!") + } + + noRRSetupTest("echo times one two") + if timesPersPre == nil { + t.Error("PreRun or PersistentPreRun not called") + } + if echoPre != nil || echoPersPre != nil || rootPersPre != nil { + t.Error("Wrong *Pre functions called!") + } + + noRRSetupTest("print one two") + if rootPersPre == nil { + t.Error("Parent PersistentPreRun not called but should not have been") + } + if echoPre != nil || echoPersPre != nil || timesPersPre != nil { + t.Error("Wrong *Pre functions called!") + } +} + +// Check if cmdEchoSub gets PersistentPreRun from rootCmd even if is added last +func TestPeristentPreRunPropagation(t *testing.T) { + rootCmd := initialize() + + // First add the cmdEchoSub to cmdPrint + cmdPrint.AddCommand(cmdEchoSub) + // Now add cmdPrint to rootCmd + rootCmd.AddCommand(cmdPrint) + + rootCmd.SetArgs(strings.Split("print echosub lala", " ")) + rootCmd.Execute() + + if rootPersPre == nil || len(rootPersPre) == 0 || rootPersPre[0] != "lala" { + t.Error("RootCmd PersistentPreRun not called but should have been") + } +} + +func TestGlobalNormFuncPropagation(t *testing.T) { + normFunc := func(f *pflag.FlagSet, name string) pflag.NormalizedName { + return pflag.NormalizedName(name) + } + + rootCmd := initialize() + rootCmd.SetGlobalNormalizationFunc(normFunc) + if reflect.ValueOf(normFunc) != reflect.ValueOf(rootCmd.GlobalNormalizationFunc()) { + t.Error("rootCmd seems to have a wrong normalization function") + } + + // First add the cmdEchoSub to cmdPrint + cmdPrint.AddCommand(cmdEchoSub) + if cmdPrint.GlobalNormalizationFunc() != nil && cmdEchoSub.GlobalNormalizationFunc() != nil { + t.Error("cmdPrint and cmdEchoSub should had no normalization functions") + } + + // Now add cmdPrint to rootCmd + rootCmd.AddCommand(cmdPrint) + if reflect.ValueOf(cmdPrint.GlobalNormalizationFunc()).Pointer() != reflect.ValueOf(rootCmd.GlobalNormalizationFunc()).Pointer() || + reflect.ValueOf(cmdEchoSub.GlobalNormalizationFunc()).Pointer() != reflect.ValueOf(rootCmd.GlobalNormalizationFunc()).Pointer() { + t.Error("cmdPrint and cmdEchoSub should had the normalization function of rootCmd") + } +} + +func TestFlagOnPflagCommandLine(t *testing.T) { + flagName := "flagOnCommandLine" + pflag.CommandLine.String(flagName, "", "about my flag") + r := fullSetupTest("--help") + + checkResultContains(t, r, flagName) +} + +func TestAddTemplateFunctions(t *testing.T) { + AddTemplateFunc("t", func() bool { return true }) + AddTemplateFuncs(template.FuncMap{ + "f": func() bool { return false }, + "h": func() string { return "Hello," }, + "w": func() string { return "world." }}) + + const usage = "Hello, world." + + c := &Command{} + c.SetUsageTemplate(`{{if t}}{{h}}{{end}}{{if f}}{{h}}{{end}} {{w}}`) + + if us := c.UsageString(); us != usage { + t.Errorf("c.UsageString() != \"%s\", is \"%s\"", usage, us) + } +} + +func TestUsageIsNotPrintedTwice(t *testing.T) { + var cmd = &Command{Use: "root"} + var sub = &Command{Use: "sub"} + cmd.AddCommand(sub) + + r := simpleTester(cmd, "") + if strings.Count(r.Output, "Usage:") != 1 { + t.Error("Usage output is not printed exactly once") + } +} diff --git a/vendor/github.com/spf13/cobra/command.go b/vendor/github.com/spf13/cobra/command.go new file mode 100644 index 000000000..aa3f33aa8 --- /dev/null +++ b/vendor/github.com/spf13/cobra/command.go @@ -0,0 +1,1217 @@ +// Copyright © 2013 Steve Francia . +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +//Package cobra is a commander providing a simple interface to create powerful modern CLI interfaces. +//In addition to providing an interface, Cobra simultaneously provides a controller to organize your application code. +package cobra + +import ( + "bytes" + "fmt" + "io" + "os" + "path/filepath" + "strings" + + flag "github.com/spf13/pflag" +) + +// Command is just that, a command for your application. +// eg. 'go run' ... 'run' is the command. Cobra requires +// you to define the usage and description as part of your command +// definition to ensure usability. +type Command struct { + // Name is the command name, usually the executable's name. + name string + // The one-line usage message. + Use string + // An array of aliases that can be used instead of the first word in Use. + Aliases []string + // An array of command names for which this command will be suggested - similar to aliases but only suggests. + SuggestFor []string + // The short description shown in the 'help' output. + Short string + // The long message shown in the 'help ' output. + Long string + // Examples of how to use the command + Example string + // List of all valid non-flag arguments that are accepted in bash completions + ValidArgs []string + // List of aliases for ValidArgs. These are not suggested to the user in the bash + // completion, but accepted if entered manually. + ArgAliases []string + // Custom functions used by the bash autocompletion generator + BashCompletionFunction string + // Is this command deprecated and should print this string when used? + Deprecated string + // Is this command hidden and should NOT show up in the list of available commands? + Hidden bool + // Full set of flags + flags *flag.FlagSet + // Set of flags childrens of this command will inherit + pflags *flag.FlagSet + // Flags that are declared specifically by this command (not inherited). + lflags *flag.FlagSet + // SilenceErrors is an option to quiet errors down stream + SilenceErrors bool + // Silence Usage is an option to silence usage when an error occurs. + SilenceUsage bool + // The *Run functions are executed in the following order: + // * PersistentPreRun() + // * PreRun() + // * Run() + // * PostRun() + // * PersistentPostRun() + // All functions get the same args, the arguments after the command name + // PersistentPreRun: children of this command will inherit and execute + PersistentPreRun func(cmd *Command, args []string) + // PersistentPreRunE: PersistentPreRun but returns an error + PersistentPreRunE func(cmd *Command, args []string) error + // PreRun: children of this command will not inherit. + PreRun func(cmd *Command, args []string) + // PreRunE: PreRun but returns an error + PreRunE func(cmd *Command, args []string) error + // Run: Typically the actual work function. Most commands will only implement this + Run func(cmd *Command, args []string) + // RunE: Run but returns an error + RunE func(cmd *Command, args []string) error + // PostRun: run after the Run command. + PostRun func(cmd *Command, args []string) + // PostRunE: PostRun but returns an error + PostRunE func(cmd *Command, args []string) error + // PersistentPostRun: children of this command will inherit and execute after PostRun + PersistentPostRun func(cmd *Command, args []string) + // PersistentPostRunE: PersistentPostRun but returns an error + PersistentPostRunE func(cmd *Command, args []string) error + // DisableAutoGenTag remove + DisableAutoGenTag bool + // Commands is the list of commands supported by this program. + commands []*Command + // Parent Command for this command + parent *Command + // max lengths of commands' string lengths for use in padding + commandsMaxUseLen int + commandsMaxCommandPathLen int + commandsMaxNameLen int + + flagErrorBuf *bytes.Buffer + + args []string // actual args parsed from flags + output *io.Writer // nil means stderr; use Out() method instead + usageFunc func(*Command) error // Usage can be defined by application + usageTemplate string // Can be defined by Application + helpTemplate string // Can be defined by Application + helpFunc func(*Command, []string) // Help can be defined by application + helpCommand *Command // The help command + // The global normalization function that we can use on every pFlag set and children commands + globNormFunc func(f *flag.FlagSet, name string) flag.NormalizedName + + // Disable the suggestions based on Levenshtein distance that go along with 'unknown command' messages + DisableSuggestions bool + // If displaying suggestions, allows to set the minimum levenshtein distance to display, must be > 0 + SuggestionsMinimumDistance int +} + +// os.Args[1:] by default, if desired, can be overridden +// particularly useful when testing. +func (c *Command) SetArgs(a []string) { + c.args = a +} + +func (c *Command) getOut(def io.Writer) io.Writer { + if c.output != nil { + return *c.output + } + + if c.HasParent() { + return c.parent.Out() + } + return def +} + +func (c *Command) Out() io.Writer { + return c.getOut(os.Stderr) +} + +func (c *Command) getOutOrStdout() io.Writer { + return c.getOut(os.Stdout) +} + +// SetOutput sets the destination for usage and error messages. +// If output is nil, os.Stderr is used. +func (c *Command) SetOutput(output io.Writer) { + c.output = &output +} + +// Usage can be defined by application +func (c *Command) SetUsageFunc(f func(*Command) error) { + c.usageFunc = f +} + +// Can be defined by Application +func (c *Command) SetUsageTemplate(s string) { + c.usageTemplate = s +} + +// Can be defined by Application +func (c *Command) SetHelpFunc(f func(*Command, []string)) { + c.helpFunc = f +} + +func (c *Command) SetHelpCommand(cmd *Command) { + c.helpCommand = cmd +} + +// Can be defined by Application +func (c *Command) SetHelpTemplate(s string) { + c.helpTemplate = s +} + +// SetGlobalNormalizationFunc sets a normalization function to all flag sets and also to child commands. +// The user should not have a cyclic dependency on commands. +func (c *Command) SetGlobalNormalizationFunc(n func(f *flag.FlagSet, name string) flag.NormalizedName) { + c.Flags().SetNormalizeFunc(n) + c.PersistentFlags().SetNormalizeFunc(n) + c.globNormFunc = n + + for _, command := range c.commands { + command.SetGlobalNormalizationFunc(n) + } +} + +func (c *Command) UsageFunc() (f func(*Command) error) { + if c.usageFunc != nil { + return c.usageFunc + } + + if c.HasParent() { + return c.parent.UsageFunc() + } + return func(c *Command) error { + err := tmpl(c.Out(), c.UsageTemplate(), c) + if err != nil { + fmt.Print(err) + } + return err + } +} + +// HelpFunc returns either the function set by SetHelpFunc for this command +// or a parent, or it returns a function which calls c.Help() +func (c *Command) HelpFunc() func(*Command, []string) { + cmd := c + for cmd != nil { + if cmd.helpFunc != nil { + return cmd.helpFunc + } + cmd = cmd.parent + } + return func(*Command, []string) { + err := c.Help() + if err != nil { + c.Println(err) + } + } +} + +var minUsagePadding = 25 + +func (c *Command) UsagePadding() int { + if c.parent == nil || minUsagePadding > c.parent.commandsMaxUseLen { + return minUsagePadding + } + return c.parent.commandsMaxUseLen +} + +var minCommandPathPadding = 11 + +// +func (c *Command) CommandPathPadding() int { + if c.parent == nil || minCommandPathPadding > c.parent.commandsMaxCommandPathLen { + return minCommandPathPadding + } + return c.parent.commandsMaxCommandPathLen +} + +var minNamePadding = 11 + +func (c *Command) NamePadding() int { + if c.parent == nil || minNamePadding > c.parent.commandsMaxNameLen { + return minNamePadding + } + return c.parent.commandsMaxNameLen +} + +func (c *Command) UsageTemplate() string { + if c.usageTemplate != "" { + return c.usageTemplate + } + + if c.HasParent() { + return c.parent.UsageTemplate() + } + return `Usage:{{if .Runnable}} + {{if .HasAvailableFlags}}{{appendIfNotPresent .UseLine "[flags]"}}{{else}}{{.UseLine}}{{end}}{{end}}{{if .HasAvailableSubCommands}} + {{ .CommandPath}} [command]{{end}}{{if gt .Aliases 0}} + +Aliases: + {{.NameAndAliases}} +{{end}}{{if .HasExample}} + +Examples: +{{ .Example }}{{end}}{{ if .HasAvailableSubCommands}} + +Available Commands:{{range .Commands}}{{if .IsAvailableCommand}} + {{rpad .Name .NamePadding }} {{.Short}}{{end}}{{end}}{{end}}{{ if .HasAvailableLocalFlags}} + +Flags: +{{.LocalFlags.FlagUsages | trimRightSpace}}{{end}}{{ if .HasAvailableInheritedFlags}} + +Global Flags: +{{.InheritedFlags.FlagUsages | trimRightSpace}}{{end}}{{if .HasHelpSubCommands}} + +Additional help topics:{{range .Commands}}{{if .IsHelpCommand}} + {{rpad .CommandPath .CommandPathPadding}} {{.Short}}{{end}}{{end}}{{end}}{{ if .HasAvailableSubCommands }} + +Use "{{.CommandPath}} [command] --help" for more information about a command.{{end}} +` +} + +func (c *Command) HelpTemplate() string { + if c.helpTemplate != "" { + return c.helpTemplate + } + + if c.HasParent() { + return c.parent.HelpTemplate() + } + return `{{with or .Long .Short }}{{. | trim}} + +{{end}}{{if or .Runnable .HasSubCommands}}{{.UsageString}}{{end}}` +} + +// Really only used when casting a command to a commander +func (c *Command) resetChildrensParents() { + for _, x := range c.commands { + x.parent = c + } +} + +// Test if the named flag is a boolean flag. +func isBooleanFlag(name string, f *flag.FlagSet) bool { + flag := f.Lookup(name) + if flag == nil { + return false + } + return flag.Value.Type() == "bool" +} + +// Test if the named flag is a boolean flag. +func isBooleanShortFlag(name string, f *flag.FlagSet) bool { + result := false + f.VisitAll(func(f *flag.Flag) { + if f.Shorthand == name && f.Value.Type() == "bool" { + result = true + } + }) + return result +} + +func stripFlags(args []string, c *Command) []string { + if len(args) < 1 { + return args + } + c.mergePersistentFlags() + + commands := []string{} + + inQuote := false + inFlag := false + for _, y := range args { + if !inQuote { + switch { + case strings.HasPrefix(y, "\""): + inQuote = true + case strings.Contains(y, "=\""): + inQuote = true + case strings.HasPrefix(y, "--") && !strings.Contains(y, "="): + // TODO: this isn't quite right, we should really check ahead for 'true' or 'false' + inFlag = !isBooleanFlag(y[2:], c.Flags()) + case strings.HasPrefix(y, "-") && !strings.Contains(y, "=") && len(y) == 2 && !isBooleanShortFlag(y[1:], c.Flags()): + inFlag = true + case inFlag: + inFlag = false + case y == "": + // strip empty commands, as the go tests expect this to be ok.... + case !strings.HasPrefix(y, "-"): + commands = append(commands, y) + inFlag = false + } + } + + if strings.HasSuffix(y, "\"") && !strings.HasSuffix(y, "\\\"") { + inQuote = false + } + } + + return commands +} + +// argsMinusFirstX removes only the first x from args. Otherwise, commands that look like +// openshift admin policy add-role-to-user admin my-user, lose the admin argument (arg[4]). +func argsMinusFirstX(args []string, x string) []string { + for i, y := range args { + if x == y { + ret := []string{} + ret = append(ret, args[:i]...) + ret = append(ret, args[i+1:]...) + return ret + } + } + return args +} + +// find the target command given the args and command tree +// Meant to be run on the highest node. Only searches down. +func (c *Command) Find(args []string) (*Command, []string, error) { + if c == nil { + return nil, nil, fmt.Errorf("Called find() on a nil Command") + } + + var innerfind func(*Command, []string) (*Command, []string) + + innerfind = func(c *Command, innerArgs []string) (*Command, []string) { + argsWOflags := stripFlags(innerArgs, c) + if len(argsWOflags) == 0 { + return c, innerArgs + } + nextSubCmd := argsWOflags[0] + matches := make([]*Command, 0) + for _, cmd := range c.commands { + if cmd.Name() == nextSubCmd || cmd.HasAlias(nextSubCmd) { // exact name or alias match + return innerfind(cmd, argsMinusFirstX(innerArgs, nextSubCmd)) + } + if EnablePrefixMatching { + if strings.HasPrefix(cmd.Name(), nextSubCmd) { // prefix match + matches = append(matches, cmd) + } + for _, x := range cmd.Aliases { + if strings.HasPrefix(x, nextSubCmd) { + matches = append(matches, cmd) + } + } + } + } + + // only accept a single prefix match - multiple matches would be ambiguous + if len(matches) == 1 { + return innerfind(matches[0], argsMinusFirstX(innerArgs, argsWOflags[0])) + } + + return c, innerArgs + } + + commandFound, a := innerfind(c, args) + argsWOflags := stripFlags(a, commandFound) + + // no subcommand, always take args + if !commandFound.HasSubCommands() { + return commandFound, a, nil + } + + // root command with subcommands, do subcommand checking + if commandFound == c && len(argsWOflags) > 0 { + suggestionsString := "" + if !c.DisableSuggestions { + if c.SuggestionsMinimumDistance <= 0 { + c.SuggestionsMinimumDistance = 2 + } + if suggestions := c.SuggestionsFor(argsWOflags[0]); len(suggestions) > 0 { + suggestionsString += "\n\nDid you mean this?\n" + for _, s := range suggestions { + suggestionsString += fmt.Sprintf("\t%v\n", s) + } + } + } + return commandFound, a, fmt.Errorf("unknown command %q for %q%s", argsWOflags[0], commandFound.CommandPath(), suggestionsString) + } + + return commandFound, a, nil +} + +func (c *Command) SuggestionsFor(typedName string) []string { + suggestions := []string{} + for _, cmd := range c.commands { + if cmd.IsAvailableCommand() { + levenshteinDistance := ld(typedName, cmd.Name(), true) + suggestByLevenshtein := levenshteinDistance <= c.SuggestionsMinimumDistance + suggestByPrefix := strings.HasPrefix(strings.ToLower(cmd.Name()), strings.ToLower(typedName)) + if suggestByLevenshtein || suggestByPrefix { + suggestions = append(suggestions, cmd.Name()) + } + for _, explicitSuggestion := range cmd.SuggestFor { + if strings.EqualFold(typedName, explicitSuggestion) { + suggestions = append(suggestions, cmd.Name()) + } + } + } + } + return suggestions +} + +func (c *Command) VisitParents(fn func(*Command)) { + var traverse func(*Command) *Command + + traverse = func(x *Command) *Command { + if x != c { + fn(x) + } + if x.HasParent() { + return traverse(x.parent) + } + return x + } + traverse(c) +} + +func (c *Command) Root() *Command { + var findRoot func(*Command) *Command + + findRoot = func(x *Command) *Command { + if x.HasParent() { + return findRoot(x.parent) + } + return x + } + + return findRoot(c) +} + +// ArgsLenAtDash will return the length of f.Args at the moment when a -- was +// found during arg parsing. This allows your program to know which args were +// before the -- and which came after. (Description from +// https://godoc.org/github.com/spf13/pflag#FlagSet.ArgsLenAtDash). +func (c *Command) ArgsLenAtDash() int { + return c.Flags().ArgsLenAtDash() +} + +func (c *Command) execute(a []string) (err error) { + if c == nil { + return fmt.Errorf("Called Execute() on a nil Command") + } + + if len(c.Deprecated) > 0 { + c.Printf("Command %q is deprecated, %s\n", c.Name(), c.Deprecated) + } + + // initialize help flag as the last point possible to allow for user + // overriding + c.initHelpFlag() + + err = c.ParseFlags(a) + if err != nil { + return err + } + // If help is called, regardless of other flags, return we want help + // Also say we need help if the command isn't runnable. + helpVal, err := c.Flags().GetBool("help") + if err != nil { + // should be impossible to get here as we always declare a help + // flag in initHelpFlag() + c.Println("\"help\" flag declared as non-bool. Please correct your code") + return err + } + if helpVal || !c.Runnable() { + return flag.ErrHelp + } + + c.preRun() + argWoFlags := c.Flags().Args() + + for p := c; p != nil; p = p.Parent() { + if p.PersistentPreRunE != nil { + if err := p.PersistentPreRunE(c, argWoFlags); err != nil { + return err + } + break + } else if p.PersistentPreRun != nil { + p.PersistentPreRun(c, argWoFlags) + break + } + } + if c.PreRunE != nil { + if err := c.PreRunE(c, argWoFlags); err != nil { + return err + } + } else if c.PreRun != nil { + c.PreRun(c, argWoFlags) + } + + if c.RunE != nil { + if err := c.RunE(c, argWoFlags); err != nil { + return err + } + } else { + c.Run(c, argWoFlags) + } + if c.PostRunE != nil { + if err := c.PostRunE(c, argWoFlags); err != nil { + return err + } + } else if c.PostRun != nil { + c.PostRun(c, argWoFlags) + } + for p := c; p != nil; p = p.Parent() { + if p.PersistentPostRunE != nil { + if err := p.PersistentPostRunE(c, argWoFlags); err != nil { + return err + } + break + } else if p.PersistentPostRun != nil { + p.PersistentPostRun(c, argWoFlags) + break + } + } + + return nil +} + +func (c *Command) preRun() { + for _, x := range initializers { + x() + } +} + +func (c *Command) errorMsgFromParse() string { + s := c.flagErrorBuf.String() + + x := strings.Split(s, "\n") + + if len(x) > 0 { + return x[0] + } + return "" +} + +// Call execute to use the args (os.Args[1:] by default) +// and run through the command tree finding appropriate matches +// for commands and then corresponding flags. +func (c *Command) Execute() error { + _, err := c.ExecuteC() + return err +} + +func (c *Command) ExecuteC() (cmd *Command, err error) { + + // Regardless of what command execute is called on, run on Root only + if c.HasParent() { + return c.Root().ExecuteC() + } + + // windows hook + if preExecHookFn != nil { + preExecHookFn(c) + } + + // initialize help as the last point possible to allow for user + // overriding + c.initHelpCmd() + + var args []string + + // Workaround FAIL with "go test -v" or "cobra.test -test.v", see #155 + if c.args == nil && filepath.Base(os.Args[0]) != "cobra.test" { + args = os.Args[1:] + } else { + args = c.args + } + + cmd, flags, err := c.Find(args) + if err != nil { + // If found parse to a subcommand and then failed, talk about the subcommand + if cmd != nil { + c = cmd + } + if !c.SilenceErrors { + c.Println("Error:", err.Error()) + c.Printf("Run '%v --help' for usage.\n", c.CommandPath()) + } + return c, err + } + err = cmd.execute(flags) + if err != nil { + // Always show help if requested, even if SilenceErrors is in + // effect + if err == flag.ErrHelp { + cmd.HelpFunc()(cmd, args) + return cmd, nil + } + + // If root command has SilentErrors flagged, + // all subcommands should respect it + if !cmd.SilenceErrors && !c.SilenceErrors { + c.Println("Error:", err.Error()) + } + + // If root command has SilentUsage flagged, + // all subcommands should respect it + if !cmd.SilenceUsage && !c.SilenceUsage { + c.Println(cmd.UsageString()) + } + return cmd, err + } + return cmd, nil +} + +func (c *Command) initHelpFlag() { + if c.Flags().Lookup("help") == nil { + c.Flags().BoolP("help", "h", false, "help for "+c.Name()) + } +} + +func (c *Command) initHelpCmd() { + if c.helpCommand == nil { + if !c.HasSubCommands() { + return + } + + c.helpCommand = &Command{ + Use: "help [command]", + Short: "Help about any command", + Long: `Help provides help for any command in the application. + Simply type ` + c.Name() + ` help [path to command] for full details.`, + PersistentPreRun: func(cmd *Command, args []string) {}, + PersistentPostRun: func(cmd *Command, args []string) {}, + + Run: func(c *Command, args []string) { + cmd, _, e := c.Root().Find(args) + if cmd == nil || e != nil { + c.Printf("Unknown help topic %#q.", args) + c.Root().Usage() + } else { + helpFunc := cmd.HelpFunc() + helpFunc(cmd, args) + } + }, + } + } + c.AddCommand(c.helpCommand) +} + +// Used for testing +func (c *Command) ResetCommands() { + c.commands = nil + c.helpCommand = nil +} + +//Commands returns a slice of child commands. +func (c *Command) Commands() []*Command { + return c.commands +} + +// AddCommand adds one or more commands to this parent command. +func (c *Command) AddCommand(cmds ...*Command) { + for i, x := range cmds { + if cmds[i] == c { + panic("Command can't be a child of itself") + } + cmds[i].parent = c + // update max lengths + usageLen := len(x.Use) + if usageLen > c.commandsMaxUseLen { + c.commandsMaxUseLen = usageLen + } + commandPathLen := len(x.CommandPath()) + if commandPathLen > c.commandsMaxCommandPathLen { + c.commandsMaxCommandPathLen = commandPathLen + } + nameLen := len(x.Name()) + if nameLen > c.commandsMaxNameLen { + c.commandsMaxNameLen = nameLen + } + // If global normalization function exists, update all children + if c.globNormFunc != nil { + x.SetGlobalNormalizationFunc(c.globNormFunc) + } + c.commands = append(c.commands, x) + } +} + +// AddCommand removes one or more commands from a parent command. +func (c *Command) RemoveCommand(cmds ...*Command) { + commands := []*Command{} +main: + for _, command := range c.commands { + for _, cmd := range cmds { + if command == cmd { + command.parent = nil + continue main + } + } + commands = append(commands, command) + } + c.commands = commands + // recompute all lengths + c.commandsMaxUseLen = 0 + c.commandsMaxCommandPathLen = 0 + c.commandsMaxNameLen = 0 + for _, command := range c.commands { + usageLen := len(command.Use) + if usageLen > c.commandsMaxUseLen { + c.commandsMaxUseLen = usageLen + } + commandPathLen := len(command.CommandPath()) + if commandPathLen > c.commandsMaxCommandPathLen { + c.commandsMaxCommandPathLen = commandPathLen + } + nameLen := len(command.Name()) + if nameLen > c.commandsMaxNameLen { + c.commandsMaxNameLen = nameLen + } + } +} + +// Print is a convenience method to Print to the defined output +func (c *Command) Print(i ...interface{}) { + fmt.Fprint(c.Out(), i...) +} + +// Println is a convenience method to Println to the defined output +func (c *Command) Println(i ...interface{}) { + str := fmt.Sprintln(i...) + c.Print(str) +} + +// Printf is a convenience method to Printf to the defined output +func (c *Command) Printf(format string, i ...interface{}) { + str := fmt.Sprintf(format, i...) + c.Print(str) +} + +// Output the usage for the command +// Used when a user provides invalid input +// Can be defined by user by overriding UsageFunc +func (c *Command) Usage() error { + c.mergePersistentFlags() + err := c.UsageFunc()(c) + return err +} + +// Output the help for the command +// Used when a user calls help [command] +// by the default HelpFunc in the commander +func (c *Command) Help() error { + c.mergePersistentFlags() + err := tmpl(c.getOutOrStdout(), c.HelpTemplate(), c) + return err +} + +func (c *Command) UsageString() string { + tmpOutput := c.output + bb := new(bytes.Buffer) + c.SetOutput(bb) + c.Usage() + c.output = tmpOutput + return bb.String() +} + +// CommandPath returns the full path to this command. +func (c *Command) CommandPath() string { + str := c.Name() + x := c + for x.HasParent() { + str = x.parent.Name() + " " + str + x = x.parent + } + return str +} + +//The full usage for a given command (including parents) +func (c *Command) UseLine() string { + str := "" + if c.HasParent() { + str = c.parent.CommandPath() + " " + } + return str + c.Use +} + +// For use in determining which flags have been assigned to which commands +// and which persist +func (c *Command) DebugFlags() { + c.Println("DebugFlags called on", c.Name()) + var debugflags func(*Command) + + debugflags = func(x *Command) { + if x.HasFlags() || x.HasPersistentFlags() { + c.Println(x.Name()) + } + if x.HasFlags() { + x.flags.VisitAll(func(f *flag.Flag) { + if x.HasPersistentFlags() { + if x.persistentFlag(f.Name) == nil { + c.Println(" -"+f.Shorthand+",", "--"+f.Name, "["+f.DefValue+"]", "", f.Value, " [L]") + } else { + c.Println(" -"+f.Shorthand+",", "--"+f.Name, "["+f.DefValue+"]", "", f.Value, " [LP]") + } + } else { + c.Println(" -"+f.Shorthand+",", "--"+f.Name, "["+f.DefValue+"]", "", f.Value, " [L]") + } + }) + } + if x.HasPersistentFlags() { + x.pflags.VisitAll(func(f *flag.Flag) { + if x.HasFlags() { + if x.flags.Lookup(f.Name) == nil { + c.Println(" -"+f.Shorthand+",", "--"+f.Name, "["+f.DefValue+"]", "", f.Value, " [P]") + } + } else { + c.Println(" -"+f.Shorthand+",", "--"+f.Name, "["+f.DefValue+"]", "", f.Value, " [P]") + } + }) + } + c.Println(x.flagErrorBuf) + if x.HasSubCommands() { + for _, y := range x.commands { + debugflags(y) + } + } + } + + debugflags(c) +} + +// Name returns the command's name: the first word in the use line. +func (c *Command) Name() string { + if c.name != "" { + return c.name + } + name := c.Use + i := strings.Index(name, " ") + if i >= 0 { + name = name[:i] + } + return name +} + +// HasAlias determines if a given string is an alias of the command. +func (c *Command) HasAlias(s string) bool { + for _, a := range c.Aliases { + if a == s { + return true + } + } + return false +} + +func (c *Command) NameAndAliases() string { + return strings.Join(append([]string{c.Name()}, c.Aliases...), ", ") +} + +func (c *Command) HasExample() bool { + return len(c.Example) > 0 +} + +// Runnable determines if the command is itself runnable +func (c *Command) Runnable() bool { + return c.Run != nil || c.RunE != nil +} + +// HasSubCommands determines if the command has children commands +func (c *Command) HasSubCommands() bool { + return len(c.commands) > 0 +} + +// IsAvailableCommand determines if a command is available as a non-help command +// (this includes all non deprecated/hidden commands) +func (c *Command) IsAvailableCommand() bool { + if len(c.Deprecated) != 0 || c.Hidden { + return false + } + + if c.HasParent() && c.Parent().helpCommand == c { + return false + } + + if c.Runnable() || c.HasAvailableSubCommands() { + return true + } + + return false +} + +// IsHelpCommand determines if a command is a 'help' command; a help command is +// determined by the fact that it is NOT runnable/hidden/deprecated, and has no +// sub commands that are runnable/hidden/deprecated +func (c *Command) IsHelpCommand() bool { + + // if a command is runnable, deprecated, or hidden it is not a 'help' command + if c.Runnable() || len(c.Deprecated) != 0 || c.Hidden { + return false + } + + // if any non-help sub commands are found, the command is not a 'help' command + for _, sub := range c.commands { + if !sub.IsHelpCommand() { + return false + } + } + + // the command either has no sub commands, or no non-help sub commands + return true +} + +// HasHelpSubCommands determines if a command has any avilable 'help' sub commands +// that need to be shown in the usage/help default template under 'additional help +// topics' +func (c *Command) HasHelpSubCommands() bool { + + // return true on the first found available 'help' sub command + for _, sub := range c.commands { + if sub.IsHelpCommand() { + return true + } + } + + // the command either has no sub commands, or no available 'help' sub commands + return false +} + +// HasAvailableSubCommands determines if a command has available sub commands that +// need to be shown in the usage/help default template under 'available commands' +func (c *Command) HasAvailableSubCommands() bool { + + // return true on the first found available (non deprecated/help/hidden) + // sub command + for _, sub := range c.commands { + if sub.IsAvailableCommand() { + return true + } + } + + // the command either has no sub comamnds, or no available (non deprecated/help/hidden) + // sub commands + return false +} + +// Determine if the command is a child command +func (c *Command) HasParent() bool { + return c.parent != nil +} + +// GlobalNormalizationFunc returns the global normalization function or nil if doesn't exists +func (c *Command) GlobalNormalizationFunc() func(f *flag.FlagSet, name string) flag.NormalizedName { + return c.globNormFunc +} + +// Get the complete FlagSet that applies to this command (local and persistent declared here and by all parents) +func (c *Command) Flags() *flag.FlagSet { + if c.flags == nil { + c.flags = flag.NewFlagSet(c.Name(), flag.ContinueOnError) + if c.flagErrorBuf == nil { + c.flagErrorBuf = new(bytes.Buffer) + } + c.flags.SetOutput(c.flagErrorBuf) + } + return c.flags +} + +// Get the local FlagSet specifically set in the current command +func (c *Command) LocalFlags() *flag.FlagSet { + c.mergePersistentFlags() + + local := flag.NewFlagSet(c.Name(), flag.ContinueOnError) + c.lflags.VisitAll(func(f *flag.Flag) { + local.AddFlag(f) + }) + if !c.HasParent() { + flag.CommandLine.VisitAll(func(f *flag.Flag) { + if local.Lookup(f.Name) == nil { + local.AddFlag(f) + } + }) + } + return local +} + +// All Flags which were inherited from parents commands +func (c *Command) InheritedFlags() *flag.FlagSet { + c.mergePersistentFlags() + + inherited := flag.NewFlagSet(c.Name(), flag.ContinueOnError) + local := c.LocalFlags() + + var rmerge func(x *Command) + + rmerge = func(x *Command) { + if x.HasPersistentFlags() { + x.PersistentFlags().VisitAll(func(f *flag.Flag) { + if inherited.Lookup(f.Name) == nil && local.Lookup(f.Name) == nil { + inherited.AddFlag(f) + } + }) + } + if x.HasParent() { + rmerge(x.parent) + } + } + + if c.HasParent() { + rmerge(c.parent) + } + + return inherited +} + +// All Flags which were not inherited from parent commands +func (c *Command) NonInheritedFlags() *flag.FlagSet { + return c.LocalFlags() +} + +// Get the Persistent FlagSet specifically set in the current command +func (c *Command) PersistentFlags() *flag.FlagSet { + if c.pflags == nil { + c.pflags = flag.NewFlagSet(c.Name(), flag.ContinueOnError) + if c.flagErrorBuf == nil { + c.flagErrorBuf = new(bytes.Buffer) + } + c.pflags.SetOutput(c.flagErrorBuf) + } + return c.pflags +} + +// For use in testing +func (c *Command) ResetFlags() { + c.flagErrorBuf = new(bytes.Buffer) + c.flagErrorBuf.Reset() + c.flags = flag.NewFlagSet(c.Name(), flag.ContinueOnError) + c.flags.SetOutput(c.flagErrorBuf) + c.pflags = flag.NewFlagSet(c.Name(), flag.ContinueOnError) + c.pflags.SetOutput(c.flagErrorBuf) +} + +// Does the command contain any flags (local plus persistent from the entire structure) +func (c *Command) HasFlags() bool { + return c.Flags().HasFlags() +} + +// Does the command contain persistent flags +func (c *Command) HasPersistentFlags() bool { + return c.PersistentFlags().HasFlags() +} + +// Does the command has flags specifically declared locally +func (c *Command) HasLocalFlags() bool { + return c.LocalFlags().HasFlags() +} + +// Does the command have flags inherited from its parent command +func (c *Command) HasInheritedFlags() bool { + return c.InheritedFlags().HasFlags() +} + +// Does the command contain any flags (local plus persistent from the entire +// structure) which are not hidden or deprecated +func (c *Command) HasAvailableFlags() bool { + return c.Flags().HasAvailableFlags() +} + +// Does the command contain persistent flags which are not hidden or deprecated +func (c *Command) HasAvailablePersistentFlags() bool { + return c.PersistentFlags().HasAvailableFlags() +} + +// Does the command has flags specifically declared locally which are not hidden +// or deprecated +func (c *Command) HasAvailableLocalFlags() bool { + return c.LocalFlags().HasAvailableFlags() +} + +// Does the command have flags inherited from its parent command which are +// not hidden or deprecated +func (c *Command) HasAvailableInheritedFlags() bool { + return c.InheritedFlags().HasAvailableFlags() +} + +// Flag climbs up the command tree looking for matching flag +func (c *Command) Flag(name string) (flag *flag.Flag) { + flag = c.Flags().Lookup(name) + + if flag == nil { + flag = c.persistentFlag(name) + } + + return +} + +// recursively find matching persistent flag +func (c *Command) persistentFlag(name string) (flag *flag.Flag) { + if c.HasPersistentFlags() { + flag = c.PersistentFlags().Lookup(name) + } + + if flag == nil && c.HasParent() { + flag = c.parent.persistentFlag(name) + } + return +} + +// ParseFlags parses persistent flag tree & local flags +func (c *Command) ParseFlags(args []string) (err error) { + c.mergePersistentFlags() + err = c.Flags().Parse(args) + return +} + +// Parent returns a commands parent command +func (c *Command) Parent() *Command { + return c.parent +} + +func (c *Command) mergePersistentFlags() { + var rmerge func(x *Command) + + // Save the set of local flags + if c.lflags == nil { + c.lflags = flag.NewFlagSet(c.Name(), flag.ContinueOnError) + if c.flagErrorBuf == nil { + c.flagErrorBuf = new(bytes.Buffer) + } + c.lflags.SetOutput(c.flagErrorBuf) + addtolocal := func(f *flag.Flag) { + c.lflags.AddFlag(f) + } + c.Flags().VisitAll(addtolocal) + c.PersistentFlags().VisitAll(addtolocal) + } + rmerge = func(x *Command) { + if !x.HasParent() { + flag.CommandLine.VisitAll(func(f *flag.Flag) { + if x.PersistentFlags().Lookup(f.Name) == nil { + x.PersistentFlags().AddFlag(f) + } + }) + } + if x.HasPersistentFlags() { + x.PersistentFlags().VisitAll(func(f *flag.Flag) { + if c.Flags().Lookup(f.Name) == nil { + c.Flags().AddFlag(f) + } + }) + } + if x.HasParent() { + rmerge(x.parent) + } + } + + rmerge(c) +} diff --git a/vendor/github.com/spf13/cobra/command_notwin.go b/vendor/github.com/spf13/cobra/command_notwin.go new file mode 100644 index 000000000..6159c1cc1 --- /dev/null +++ b/vendor/github.com/spf13/cobra/command_notwin.go @@ -0,0 +1,5 @@ +// +build !windows + +package cobra + +var preExecHookFn func(*Command) diff --git a/vendor/github.com/spf13/cobra/command_test.go b/vendor/github.com/spf13/cobra/command_test.go new file mode 100644 index 000000000..43ed7a34f --- /dev/null +++ b/vendor/github.com/spf13/cobra/command_test.go @@ -0,0 +1,114 @@ +package cobra + +import ( + "reflect" + "testing" +) + +// test to ensure hidden commands run as intended +func TestHiddenCommandExecutes(t *testing.T) { + + // ensure that outs does not already equal what the command will be setting it + // to, if it did this test would not actually be testing anything... + if outs == "hidden" { + t.Errorf("outs should NOT EQUAL hidden") + } + + cmdHidden.Execute() + + // upon running the command, the value of outs should now be 'hidden' + if outs != "hidden" { + t.Errorf("Hidden command failed to run!") + } +} + +// test to ensure hidden commands do not show up in usage/help text +func TestHiddenCommandIsHidden(t *testing.T) { + if cmdHidden.IsAvailableCommand() { + t.Errorf("Hidden command found!") + } +} + +func TestStripFlags(t *testing.T) { + tests := []struct { + input []string + output []string + }{ + { + []string{"foo", "bar"}, + []string{"foo", "bar"}, + }, + { + []string{"foo", "--bar", "-b"}, + []string{"foo"}, + }, + { + []string{"-b", "foo", "--bar", "bar"}, + []string{}, + }, + { + []string{"-i10", "echo"}, + []string{"echo"}, + }, + { + []string{"-i=10", "echo"}, + []string{"echo"}, + }, + { + []string{"--int=100", "echo"}, + []string{"echo"}, + }, + { + []string{"-ib", "echo", "-bfoo", "baz"}, + []string{"echo", "baz"}, + }, + { + []string{"-i=baz", "bar", "-i", "foo", "blah"}, + []string{"bar", "blah"}, + }, + { + []string{"--int=baz", "-bbar", "-i", "foo", "blah"}, + []string{"blah"}, + }, + { + []string{"--cat", "bar", "-i", "foo", "blah"}, + []string{"bar", "blah"}, + }, + { + []string{"-c", "bar", "-i", "foo", "blah"}, + []string{"bar", "blah"}, + }, + { + []string{"--persist", "bar"}, + []string{"bar"}, + }, + { + []string{"-p", "bar"}, + []string{"bar"}, + }, + } + + cmdPrint := &Command{ + Use: "print [string to print]", + Short: "Print anything to the screen", + Long: `an utterly useless command for testing.`, + Run: func(cmd *Command, args []string) { + tp = args + }, + } + + var flagi int + var flagstr string + var flagbool bool + cmdPrint.PersistentFlags().BoolVarP(&flagbool, "persist", "p", false, "help for persistent one") + cmdPrint.Flags().IntVarP(&flagi, "int", "i", 345, "help message for flag int") + cmdPrint.Flags().StringVarP(&flagstr, "bar", "b", "bar", "help message for flag string") + cmdPrint.Flags().BoolVarP(&flagbool, "cat", "c", false, "help message for flag bool") + + for _, test := range tests { + output := stripFlags(test.input, cmdPrint) + if !reflect.DeepEqual(test.output, output) { + t.Errorf("expected: %v, got: %v", test.output, output) + } + } +} diff --git a/vendor/github.com/spf13/cobra/command_win.go b/vendor/github.com/spf13/cobra/command_win.go new file mode 100644 index 000000000..4b0eaa1b6 --- /dev/null +++ b/vendor/github.com/spf13/cobra/command_win.go @@ -0,0 +1,26 @@ +// +build windows + +package cobra + +import ( + "os" + "time" + + "github.com/inconshreveable/mousetrap" +) + +var preExecHookFn = preExecHook + +// enables an information splash screen on Windows if the CLI is started from explorer.exe. +var MousetrapHelpText string = `This is a command line tool + +You need to open cmd.exe and run it from there. +` + +func preExecHook(c *Command) { + if mousetrap.StartedByExplorer() { + c.Print(MousetrapHelpText) + time.Sleep(5 * time.Second) + os.Exit(1) + } +} diff --git a/vendor/github.com/spf13/pflag/LICENSE b/vendor/github.com/spf13/pflag/LICENSE new file mode 100644 index 000000000..63ed1cfea --- /dev/null +++ b/vendor/github.com/spf13/pflag/LICENSE @@ -0,0 +1,28 @@ +Copyright (c) 2012 Alex Ogier. All rights reserved. +Copyright (c) 2012 The Go Authors. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/vendor/github.com/spf13/pflag/README.md b/vendor/github.com/spf13/pflag/README.md new file mode 100644 index 000000000..0bafd385f --- /dev/null +++ b/vendor/github.com/spf13/pflag/README.md @@ -0,0 +1,256 @@ +[![Build Status](https://travis-ci.org/spf13/pflag.svg?branch=master)](https://travis-ci.org/spf13/pflag) + +## Description + +pflag is a drop-in replacement for Go's flag package, implementing +POSIX/GNU-style --flags. + +pflag is compatible with the [GNU extensions to the POSIX recommendations +for command-line options][1]. For a more precise description, see the +"Command-line flag syntax" section below. + +[1]: http://www.gnu.org/software/libc/manual/html_node/Argument-Syntax.html + +pflag is available under the same style of BSD license as the Go language, +which can be found in the LICENSE file. + +## Installation + +pflag is available using the standard `go get` command. + +Install by running: + + go get github.com/spf13/pflag + +Run tests by running: + + go test github.com/spf13/pflag + +## Usage + +pflag is a drop-in replacement of Go's native flag package. If you import +pflag under the name "flag" then all code should continue to function +with no changes. + +``` go +import flag "github.com/spf13/pflag" +``` + +There is one exception to this: if you directly instantiate the Flag struct +there is one more field "Shorthand" that you will need to set. +Most code never instantiates this struct directly, and instead uses +functions such as String(), BoolVar(), and Var(), and is therefore +unaffected. + +Define flags using flag.String(), Bool(), Int(), etc. + +This declares an integer flag, -flagname, stored in the pointer ip, with type *int. + +``` go +var ip *int = flag.Int("flagname", 1234, "help message for flagname") +``` + +If you like, you can bind the flag to a variable using the Var() functions. + +``` go +var flagvar int +func init() { + flag.IntVar(&flagvar, "flagname", 1234, "help message for flagname") +} +``` + +Or you can create custom flags that satisfy the Value interface (with +pointer receivers) and couple them to flag parsing by + +``` go +flag.Var(&flagVal, "name", "help message for flagname") +``` + +For such flags, the default value is just the initial value of the variable. + +After all flags are defined, call + +``` go +flag.Parse() +``` + +to parse the command line into the defined flags. + +Flags may then be used directly. If you're using the flags themselves, +they are all pointers; if you bind to variables, they're values. + +``` go +fmt.Println("ip has value ", *ip) +fmt.Println("flagvar has value ", flagvar) +``` + +There are helpers function to get values later if you have the FlagSet but +it was difficult to keep up with all of the flag pointers in your code. +If you have a pflag.FlagSet with a flag called 'flagname' of type int you +can use GetInt() to get the int value. But notice that 'flagname' must exist +and it must be an int. GetString("flagname") will fail. + +``` go +i, err := flagset.GetInt("flagname") +``` + +After parsing, the arguments after the flag are available as the +slice flag.Args() or individually as flag.Arg(i). +The arguments are indexed from 0 through flag.NArg()-1. + +The pflag package also defines some new functions that are not in flag, +that give one-letter shorthands for flags. You can use these by appending +'P' to the name of any function that defines a flag. + +``` go +var ip = flag.IntP("flagname", "f", 1234, "help message") +var flagvar bool +func init() { + flag.BoolVarP("boolname", "b", true, "help message") +} +flag.VarP(&flagVar, "varname", "v", 1234, "help message") +``` + +Shorthand letters can be used with single dashes on the command line. +Boolean shorthand flags can be combined with other shorthand flags. + +The default set of command-line flags is controlled by +top-level functions. The FlagSet type allows one to define +independent sets of flags, such as to implement subcommands +in a command-line interface. The methods of FlagSet are +analogous to the top-level functions for the command-line +flag set. + +## Setting no option default values for flags + +After you create a flag it is possible to set the pflag.NoOptDefVal for +the given flag. Doing this changes the meaning of the flag slightly. If +a flag has a NoOptDefVal and the flag is set on the command line without +an option the flag will be set to the NoOptDefVal. For example given: + +``` go +var ip = flag.IntP("flagname", "f", 1234, "help message") +flag.Lookup("flagname").NoOptDefVal = "4321" +``` + +Would result in something like + +| Parsed Arguments | Resulting Value | +| ------------- | ------------- | +| --flagname=1357 | ip=1357 | +| --flagname | ip=4321 | +| [nothing] | ip=1234 | + +## Command line flag syntax + +``` +--flag // boolean flags, or flags with no option default values +--flag x // only on flags without a default value +--flag=x +``` + +Unlike the flag package, a single dash before an option means something +different than a double dash. Single dashes signify a series of shorthand +letters for flags. All but the last shorthand letter must be boolean flags +or a flag with a default value + +``` +// boolean or flags where the 'no option default value' is set +-f +-f=true +-abc +but +-b true is INVALID + +// non-boolean and flags without a 'no option default value' +-n 1234 +-n=1234 +-n1234 + +// mixed +-abcs "hello" +-absd="hello" +-abcs1234 +``` + +Flag parsing stops after the terminator "--". Unlike the flag package, +flags can be interspersed with arguments anywhere on the command line +before this terminator. + +Integer flags accept 1234, 0664, 0x1234 and may be negative. +Boolean flags (in their long form) accept 1, 0, t, f, true, false, +TRUE, FALSE, True, False. +Duration flags accept any input valid for time.ParseDuration. + +## Mutating or "Normalizing" Flag names + +It is possible to set a custom flag name 'normalization function.' It allows flag names to be mutated both when created in the code and when used on the command line to some 'normalized' form. The 'normalized' form is used for comparison. Two examples of using the custom normalization func follow. + +**Example #1**: You want -, _, and . in flags to compare the same. aka --my-flag == --my_flag == --my.flag + +``` go +func wordSepNormalizeFunc(f *pflag.FlagSet, name string) pflag.NormalizedName { + from := []string{"-", "_"} + to := "." + for _, sep := range from { + name = strings.Replace(name, sep, to, -1) + } + return pflag.NormalizedName(name) +} + +myFlagSet.SetNormalizeFunc(wordSepNormalizeFunc) +``` + +**Example #2**: You want to alias two flags. aka --old-flag-name == --new-flag-name + +``` go +func aliasNormalizeFunc(f *pflag.FlagSet, name string) pflag.NormalizedName { + switch name { + case "old-flag-name": + name = "new-flag-name" + break + } + return pflag.NormalizedName(name) +} + +myFlagSet.SetNormalizeFunc(aliasNormalizeFunc) +``` + +## Deprecating a flag or its shorthand +It is possible to deprecate a flag, or just its shorthand. Deprecating a flag/shorthand hides it from help text and prints a usage message when the deprecated flag/shorthand is used. + +**Example #1**: You want to deprecate a flag named "badflag" as well as inform the users what flag they should use instead. +```go +// deprecate a flag by specifying its name and a usage message +flags.MarkDeprecated("badflag", "please use --good-flag instead") +``` +This hides "badflag" from help text, and prints `Flag --badflag has been deprecated, please use --good-flag instead` when "badflag" is used. + +**Example #2**: You want to keep a flag name "noshorthandflag" but deprecate its shortname "n". +```go +// deprecate a flag shorthand by specifying its flag name and a usage message +flags.MarkShorthandDeprecated("noshorthandflag", "please use --noshorthandflag only") +``` +This hides the shortname "n" from help text, and prints `Flag shorthand -n has been deprecated, please use --noshorthandflag only` when the shorthand "n" is used. + +Note that usage message is essential here, and it should not be empty. + +## Hidden flags +It is possible to mark a flag as hidden, meaning it will still function as normal, however will not show up in usage/help text. + +**Example**: You have a flag named "secretFlag" that you need for internal use only and don't want it showing up in help text, or for its usage text to be available. +```go +// hide a flag by specifying its name +flags.MarkHidden("secretFlag") +``` + +## More info + +You can see the full reference documentation of the pflag package +[at godoc.org][3], or through go's standard documentation system by +running `godoc -http=:6060` and browsing to +[http://localhost:6060/pkg/github.com/ogier/pflag][2] after +installation. + +[2]: http://localhost:6060/pkg/github.com/ogier/pflag +[3]: http://godoc.org/github.com/ogier/pflag diff --git a/vendor/github.com/spf13/pflag/bool.go b/vendor/github.com/spf13/pflag/bool.go new file mode 100644 index 000000000..d272e40bd --- /dev/null +++ b/vendor/github.com/spf13/pflag/bool.go @@ -0,0 +1,97 @@ +package pflag + +import ( + "fmt" + "strconv" +) + +// optional interface to indicate boolean flags that can be +// supplied without "=value" text +type boolFlag interface { + Value + IsBoolFlag() bool +} + +// -- bool Value +type boolValue bool + +func newBoolValue(val bool, p *bool) *boolValue { + *p = val + return (*boolValue)(p) +} + +func (b *boolValue) Set(s string) error { + v, err := strconv.ParseBool(s) + *b = boolValue(v) + return err +} + +func (b *boolValue) Type() string { + return "bool" +} + +func (b *boolValue) String() string { return fmt.Sprintf("%v", *b) } + +func (b *boolValue) IsBoolFlag() bool { return true } + +func boolConv(sval string) (interface{}, error) { + return strconv.ParseBool(sval) +} + +// GetBool return the bool value of a flag with the given name +func (f *FlagSet) GetBool(name string) (bool, error) { + val, err := f.getFlagType(name, "bool", boolConv) + if err != nil { + return false, err + } + return val.(bool), nil +} + +// BoolVar defines a bool flag with specified name, default value, and usage string. +// The argument p points to a bool variable in which to store the value of the flag. +func (f *FlagSet) BoolVar(p *bool, name string, value bool, usage string) { + f.BoolVarP(p, name, "", value, usage) +} + +// BoolVarP is like BoolVar, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) BoolVarP(p *bool, name, shorthand string, value bool, usage string) { + flag := f.VarPF(newBoolValue(value, p), name, shorthand, usage) + flag.NoOptDefVal = "true" +} + +// BoolVar defines a bool flag with specified name, default value, and usage string. +// The argument p points to a bool variable in which to store the value of the flag. +func BoolVar(p *bool, name string, value bool, usage string) { + BoolVarP(p, name, "", value, usage) +} + +// BoolVarP is like BoolVar, but accepts a shorthand letter that can be used after a single dash. +func BoolVarP(p *bool, name, shorthand string, value bool, usage string) { + flag := CommandLine.VarPF(newBoolValue(value, p), name, shorthand, usage) + flag.NoOptDefVal = "true" +} + +// Bool defines a bool flag with specified name, default value, and usage string. +// The return value is the address of a bool variable that stores the value of the flag. +func (f *FlagSet) Bool(name string, value bool, usage string) *bool { + return f.BoolP(name, "", value, usage) +} + +// BoolP is like Bool, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) BoolP(name, shorthand string, value bool, usage string) *bool { + p := new(bool) + f.BoolVarP(p, name, shorthand, value, usage) + return p +} + +// Bool defines a bool flag with specified name, default value, and usage string. +// The return value is the address of a bool variable that stores the value of the flag. +func Bool(name string, value bool, usage string) *bool { + return BoolP(name, "", value, usage) +} + +// BoolP is like Bool, but accepts a shorthand letter that can be used after a single dash. +func BoolP(name, shorthand string, value bool, usage string) *bool { + b := CommandLine.BoolP(name, shorthand, value, usage) + return b +} diff --git a/vendor/github.com/spf13/pflag/bool_test.go b/vendor/github.com/spf13/pflag/bool_test.go new file mode 100644 index 000000000..afd25ae2f --- /dev/null +++ b/vendor/github.com/spf13/pflag/bool_test.go @@ -0,0 +1,180 @@ +// Copyright 2009 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package pflag + +import ( + "bytes" + "fmt" + "strconv" + "testing" +) + +// This value can be a boolean ("true", "false") or "maybe" +type triStateValue int + +const ( + triStateFalse triStateValue = 0 + triStateTrue triStateValue = 1 + triStateMaybe triStateValue = 2 +) + +const strTriStateMaybe = "maybe" + +func (v *triStateValue) IsBoolFlag() bool { + return true +} + +func (v *triStateValue) Get() interface{} { + return triStateValue(*v) +} + +func (v *triStateValue) Set(s string) error { + if s == strTriStateMaybe { + *v = triStateMaybe + return nil + } + boolVal, err := strconv.ParseBool(s) + if boolVal { + *v = triStateTrue + } else { + *v = triStateFalse + } + return err +} + +func (v *triStateValue) String() string { + if *v == triStateMaybe { + return strTriStateMaybe + } + return fmt.Sprintf("%v", bool(*v == triStateTrue)) +} + +// The type of the flag as required by the pflag.Value interface +func (v *triStateValue) Type() string { + return "version" +} + +func setUpFlagSet(tristate *triStateValue) *FlagSet { + f := NewFlagSet("test", ContinueOnError) + *tristate = triStateFalse + flag := f.VarPF(tristate, "tristate", "t", "tristate value (true, maybe or false)") + flag.NoOptDefVal = "true" + return f +} + +func TestExplicitTrue(t *testing.T) { + var tristate triStateValue + f := setUpFlagSet(&tristate) + err := f.Parse([]string{"--tristate=true"}) + if err != nil { + t.Fatal("expected no error; got", err) + } + if tristate != triStateTrue { + t.Fatal("expected", triStateTrue, "(triStateTrue) but got", tristate, "instead") + } +} + +func TestImplicitTrue(t *testing.T) { + var tristate triStateValue + f := setUpFlagSet(&tristate) + err := f.Parse([]string{"--tristate"}) + if err != nil { + t.Fatal("expected no error; got", err) + } + if tristate != triStateTrue { + t.Fatal("expected", triStateTrue, "(triStateTrue) but got", tristate, "instead") + } +} + +func TestShortFlag(t *testing.T) { + var tristate triStateValue + f := setUpFlagSet(&tristate) + err := f.Parse([]string{"-t"}) + if err != nil { + t.Fatal("expected no error; got", err) + } + if tristate != triStateTrue { + t.Fatal("expected", triStateTrue, "(triStateTrue) but got", tristate, "instead") + } +} + +func TestShortFlagExtraArgument(t *testing.T) { + var tristate triStateValue + f := setUpFlagSet(&tristate) + // The"maybe"turns into an arg, since short boolean options will only do true/false + err := f.Parse([]string{"-t", "maybe"}) + if err != nil { + t.Fatal("expected no error; got", err) + } + if tristate != triStateTrue { + t.Fatal("expected", triStateTrue, "(triStateTrue) but got", tristate, "instead") + } + args := f.Args() + if len(args) != 1 || args[0] != "maybe" { + t.Fatal("expected an extra 'maybe' argument to stick around") + } +} + +func TestExplicitMaybe(t *testing.T) { + var tristate triStateValue + f := setUpFlagSet(&tristate) + err := f.Parse([]string{"--tristate=maybe"}) + if err != nil { + t.Fatal("expected no error; got", err) + } + if tristate != triStateMaybe { + t.Fatal("expected", triStateMaybe, "(triStateMaybe) but got", tristate, "instead") + } +} + +func TestExplicitFalse(t *testing.T) { + var tristate triStateValue + f := setUpFlagSet(&tristate) + err := f.Parse([]string{"--tristate=false"}) + if err != nil { + t.Fatal("expected no error; got", err) + } + if tristate != triStateFalse { + t.Fatal("expected", triStateFalse, "(triStateFalse) but got", tristate, "instead") + } +} + +func TestImplicitFalse(t *testing.T) { + var tristate triStateValue + f := setUpFlagSet(&tristate) + err := f.Parse([]string{}) + if err != nil { + t.Fatal("expected no error; got", err) + } + if tristate != triStateFalse { + t.Fatal("expected", triStateFalse, "(triStateFalse) but got", tristate, "instead") + } +} + +func TestInvalidValue(t *testing.T) { + var tristate triStateValue + f := setUpFlagSet(&tristate) + var buf bytes.Buffer + f.SetOutput(&buf) + err := f.Parse([]string{"--tristate=invalid"}) + if err == nil { + t.Fatal("expected an error but did not get any, tristate has value", tristate) + } +} + +func TestBoolP(t *testing.T) { + b := BoolP("bool", "b", false, "bool value in CommandLine") + c := BoolP("c", "c", false, "other bool value") + args := []string{"--bool"} + if err := CommandLine.Parse(args); err != nil { + t.Error("expected no error, got ", err) + } + if *b != true { + t.Errorf("expected b=true got b=%s", b) + } + if *c != false { + t.Errorf("expect c=false got c=%s", c) + } +} diff --git a/vendor/github.com/spf13/pflag/count.go b/vendor/github.com/spf13/pflag/count.go new file mode 100644 index 000000000..7b1f142e7 --- /dev/null +++ b/vendor/github.com/spf13/pflag/count.go @@ -0,0 +1,97 @@ +package pflag + +import ( + "fmt" + "strconv" +) + +// -- count Value +type countValue int + +func newCountValue(val int, p *int) *countValue { + *p = val + return (*countValue)(p) +} + +func (i *countValue) Set(s string) error { + v, err := strconv.ParseInt(s, 0, 64) + // -1 means that no specific value was passed, so increment + if v == -1 { + *i = countValue(*i + 1) + } else { + *i = countValue(v) + } + return err +} + +func (i *countValue) Type() string { + return "count" +} + +func (i *countValue) String() string { return fmt.Sprintf("%v", *i) } + +func countConv(sval string) (interface{}, error) { + i, err := strconv.Atoi(sval) + if err != nil { + return nil, err + } + return i, nil +} + +// GetCount return the int value of a flag with the given name +func (f *FlagSet) GetCount(name string) (int, error) { + val, err := f.getFlagType(name, "count", countConv) + if err != nil { + return 0, err + } + return val.(int), nil +} + +// CountVar defines a count flag with specified name, default value, and usage string. +// The argument p points to an int variable in which to store the value of the flag. +// A count flag will add 1 to its value evey time it is found on the command line +func (f *FlagSet) CountVar(p *int, name string, usage string) { + f.CountVarP(p, name, "", usage) +} + +// CountVarP is like CountVar only take a shorthand for the flag name. +func (f *FlagSet) CountVarP(p *int, name, shorthand string, usage string) { + flag := f.VarPF(newCountValue(0, p), name, shorthand, usage) + flag.NoOptDefVal = "-1" +} + +// CountVar like CountVar only the flag is placed on the CommandLine instead of a given flag set +func CountVar(p *int, name string, usage string) { + CommandLine.CountVar(p, name, usage) +} + +// CountVarP is like CountVar only take a shorthand for the flag name. +func CountVarP(p *int, name, shorthand string, usage string) { + CommandLine.CountVarP(p, name, shorthand, usage) +} + +// Count defines a count flag with specified name, default value, and usage string. +// The return value is the address of an int variable that stores the value of the flag. +// A count flag will add 1 to its value evey time it is found on the command line +func (f *FlagSet) Count(name string, usage string) *int { + p := new(int) + f.CountVarP(p, name, "", usage) + return p +} + +// CountP is like Count only takes a shorthand for the flag name. +func (f *FlagSet) CountP(name, shorthand string, usage string) *int { + p := new(int) + f.CountVarP(p, name, shorthand, usage) + return p +} + +// Count like Count only the flag is placed on the CommandLine isntead of a given flag set +func Count(name string, usage string) *int { + return CommandLine.CountP(name, "", usage) +} + +// CountP is like Count only takes a shorthand for the flag name. +func CountP(name, shorthand string, usage string) *int { + return CommandLine.CountP(name, shorthand, usage) +} diff --git a/vendor/github.com/spf13/pflag/count_test.go b/vendor/github.com/spf13/pflag/count_test.go new file mode 100644 index 000000000..716765cba --- /dev/null +++ b/vendor/github.com/spf13/pflag/count_test.go @@ -0,0 +1,55 @@ +package pflag + +import ( + "fmt" + "os" + "testing" +) + +var _ = fmt.Printf + +func setUpCount(c *int) *FlagSet { + f := NewFlagSet("test", ContinueOnError) + f.CountVarP(c, "verbose", "v", "a counter") + return f +} + +func TestCount(t *testing.T) { + testCases := []struct { + input []string + success bool + expected int + }{ + {[]string{"-vvv"}, true, 3}, + {[]string{"-v", "-v", "-v"}, true, 3}, + {[]string{"-v", "--verbose", "-v"}, true, 3}, + {[]string{"-v=3", "-v"}, true, 4}, + {[]string{"-v=a"}, false, 0}, + } + + devnull, _ := os.Open(os.DevNull) + os.Stderr = devnull + for i := range testCases { + var count int + f := setUpCount(&count) + + tc := &testCases[i] + + err := f.Parse(tc.input) + if err != nil && tc.success == true { + t.Errorf("expected success, got %q", err) + continue + } else if err == nil && tc.success == false { + t.Errorf("expected failure, got success") + continue + } else if tc.success { + c, err := f.GetCount("verbose") + if err != nil { + t.Errorf("Got error trying to fetch the counter flag") + } + if c != tc.expected { + t.Errorf("expected %q, got %q", tc.expected, c) + } + } + } +} diff --git a/vendor/github.com/spf13/pflag/duration.go b/vendor/github.com/spf13/pflag/duration.go new file mode 100644 index 000000000..e9debef88 --- /dev/null +++ b/vendor/github.com/spf13/pflag/duration.go @@ -0,0 +1,86 @@ +package pflag + +import ( + "time" +) + +// -- time.Duration Value +type durationValue time.Duration + +func newDurationValue(val time.Duration, p *time.Duration) *durationValue { + *p = val + return (*durationValue)(p) +} + +func (d *durationValue) Set(s string) error { + v, err := time.ParseDuration(s) + *d = durationValue(v) + return err +} + +func (d *durationValue) Type() string { + return "duration" +} + +func (d *durationValue) String() string { return (*time.Duration)(d).String() } + +func durationConv(sval string) (interface{}, error) { + return time.ParseDuration(sval) +} + +// GetDuration return the duration value of a flag with the given name +func (f *FlagSet) GetDuration(name string) (time.Duration, error) { + val, err := f.getFlagType(name, "duration", durationConv) + if err != nil { + return 0, err + } + return val.(time.Duration), nil +} + +// DurationVar defines a time.Duration flag with specified name, default value, and usage string. +// The argument p points to a time.Duration variable in which to store the value of the flag. +func (f *FlagSet) DurationVar(p *time.Duration, name string, value time.Duration, usage string) { + f.VarP(newDurationValue(value, p), name, "", usage) +} + +// DurationVarP is like DurationVar, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) DurationVarP(p *time.Duration, name, shorthand string, value time.Duration, usage string) { + f.VarP(newDurationValue(value, p), name, shorthand, usage) +} + +// DurationVar defines a time.Duration flag with specified name, default value, and usage string. +// The argument p points to a time.Duration variable in which to store the value of the flag. +func DurationVar(p *time.Duration, name string, value time.Duration, usage string) { + CommandLine.VarP(newDurationValue(value, p), name, "", usage) +} + +// DurationVarP is like DurationVar, but accepts a shorthand letter that can be used after a single dash. +func DurationVarP(p *time.Duration, name, shorthand string, value time.Duration, usage string) { + CommandLine.VarP(newDurationValue(value, p), name, shorthand, usage) +} + +// Duration defines a time.Duration flag with specified name, default value, and usage string. +// The return value is the address of a time.Duration variable that stores the value of the flag. +func (f *FlagSet) Duration(name string, value time.Duration, usage string) *time.Duration { + p := new(time.Duration) + f.DurationVarP(p, name, "", value, usage) + return p +} + +// DurationP is like Duration, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) DurationP(name, shorthand string, value time.Duration, usage string) *time.Duration { + p := new(time.Duration) + f.DurationVarP(p, name, shorthand, value, usage) + return p +} + +// Duration defines a time.Duration flag with specified name, default value, and usage string. +// The return value is the address of a time.Duration variable that stores the value of the flag. +func Duration(name string, value time.Duration, usage string) *time.Duration { + return CommandLine.DurationP(name, "", value, usage) +} + +// DurationP is like Duration, but accepts a shorthand letter that can be used after a single dash. +func DurationP(name, shorthand string, value time.Duration, usage string) *time.Duration { + return CommandLine.DurationP(name, shorthand, value, usage) +} diff --git a/vendor/github.com/spf13/pflag/example_test.go b/vendor/github.com/spf13/pflag/example_test.go new file mode 100644 index 000000000..9be7a49f2 --- /dev/null +++ b/vendor/github.com/spf13/pflag/example_test.go @@ -0,0 +1,77 @@ +// Copyright 2012 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// These examples demonstrate more intricate uses of the flag package. +package pflag_test + +import ( + "errors" + "fmt" + "strings" + "time" + + flag "github.com/spf13/pflag" +) + +// Example 1: A single string flag called "species" with default value "gopher". +var species = flag.String("species", "gopher", "the species we are studying") + +// Example 2: A flag with a shorthand letter. +var gopherType = flag.StringP("gopher_type", "g", "pocket", "the variety of gopher") + +// Example 3: A user-defined flag type, a slice of durations. +type interval []time.Duration + +// String is the method to format the flag's value, part of the flag.Value interface. +// The String method's output will be used in diagnostics. +func (i *interval) String() string { + return fmt.Sprint(*i) +} + +func (i *interval) Type() string { + return "interval" +} + +// Set is the method to set the flag value, part of the flag.Value interface. +// Set's argument is a string to be parsed to set the flag. +// It's a comma-separated list, so we split it. +func (i *interval) Set(value string) error { + // If we wanted to allow the flag to be set multiple times, + // accumulating values, we would delete this if statement. + // That would permit usages such as + // -deltaT 10s -deltaT 15s + // and other combinations. + if len(*i) > 0 { + return errors.New("interval flag already set") + } + for _, dt := range strings.Split(value, ",") { + duration, err := time.ParseDuration(dt) + if err != nil { + return err + } + *i = append(*i, duration) + } + return nil +} + +// Define a flag to accumulate durations. Because it has a special type, +// we need to use the Var function and therefore create the flag during +// init. + +var intervalFlag interval + +func init() { + // Tie the command-line flag to the intervalFlag variable and + // set a usage message. + flag.Var(&intervalFlag, "deltaT", "comma-separated list of intervals to use between events") +} + +func Example() { + // All the interesting pieces are with the variables declared above, but + // to enable the flag package to see the flags defined there, one must + // execute, typically at the start of main (not init!): + // flag.Parse() + // We don't run it here because this is not a main function and + // the testing suite has already parsed the flags. +} diff --git a/vendor/github.com/spf13/pflag/export_test.go b/vendor/github.com/spf13/pflag/export_test.go new file mode 100644 index 000000000..9318fee00 --- /dev/null +++ b/vendor/github.com/spf13/pflag/export_test.go @@ -0,0 +1,29 @@ +// Copyright 2010 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package pflag + +import ( + "io/ioutil" + "os" +) + +// Additional routines compiled into the package only during testing. + +// ResetForTesting clears all flag state and sets the usage function as directed. +// After calling ResetForTesting, parse errors in flag handling will not +// exit the program. +func ResetForTesting(usage func()) { + CommandLine = &FlagSet{ + name: os.Args[0], + errorHandling: ContinueOnError, + output: ioutil.Discard, + } + Usage = usage +} + +// GetCommandLine returns the default FlagSet. +func GetCommandLine() *FlagSet { + return CommandLine +} diff --git a/vendor/github.com/spf13/pflag/flag.go b/vendor/github.com/spf13/pflag/flag.go new file mode 100644 index 000000000..965df1379 --- /dev/null +++ b/vendor/github.com/spf13/pflag/flag.go @@ -0,0 +1,934 @@ +// Copyright 2009 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +/* +Package pflag is a drop-in replacement for Go's flag package, implementing +POSIX/GNU-style --flags. + +pflag is compatible with the GNU extensions to the POSIX recommendations +for command-line options. See +http://www.gnu.org/software/libc/manual/html_node/Argument-Syntax.html + +Usage: + +pflag is a drop-in replacement of Go's native flag package. If you import +pflag under the name "flag" then all code should continue to function +with no changes. + + import flag "github.com/ogier/pflag" + + There is one exception to this: if you directly instantiate the Flag struct +there is one more field "Shorthand" that you will need to set. +Most code never instantiates this struct directly, and instead uses +functions such as String(), BoolVar(), and Var(), and is therefore +unaffected. + +Define flags using flag.String(), Bool(), Int(), etc. + +This declares an integer flag, -flagname, stored in the pointer ip, with type *int. + var ip = flag.Int("flagname", 1234, "help message for flagname") +If you like, you can bind the flag to a variable using the Var() functions. + var flagvar int + func init() { + flag.IntVar(&flagvar, "flagname", 1234, "help message for flagname") + } +Or you can create custom flags that satisfy the Value interface (with +pointer receivers) and couple them to flag parsing by + flag.Var(&flagVal, "name", "help message for flagname") +For such flags, the default value is just the initial value of the variable. + +After all flags are defined, call + flag.Parse() +to parse the command line into the defined flags. + +Flags may then be used directly. If you're using the flags themselves, +they are all pointers; if you bind to variables, they're values. + fmt.Println("ip has value ", *ip) + fmt.Println("flagvar has value ", flagvar) + +After parsing, the arguments after the flag are available as the +slice flag.Args() or individually as flag.Arg(i). +The arguments are indexed from 0 through flag.NArg()-1. + +The pflag package also defines some new functions that are not in flag, +that give one-letter shorthands for flags. You can use these by appending +'P' to the name of any function that defines a flag. + var ip = flag.IntP("flagname", "f", 1234, "help message") + var flagvar bool + func init() { + flag.BoolVarP("boolname", "b", true, "help message") + } + flag.VarP(&flagVar, "varname", "v", 1234, "help message") +Shorthand letters can be used with single dashes on the command line. +Boolean shorthand flags can be combined with other shorthand flags. + +Command line flag syntax: + --flag // boolean flags only + --flag=x + +Unlike the flag package, a single dash before an option means something +different than a double dash. Single dashes signify a series of shorthand +letters for flags. All but the last shorthand letter must be boolean flags. + // boolean flags + -f + -abc + // non-boolean flags + -n 1234 + -Ifile + // mixed + -abcs "hello" + -abcn1234 + +Flag parsing stops after the terminator "--". Unlike the flag package, +flags can be interspersed with arguments anywhere on the command line +before this terminator. + +Integer flags accept 1234, 0664, 0x1234 and may be negative. +Boolean flags (in their long form) accept 1, 0, t, f, true, false, +TRUE, FALSE, True, False. +Duration flags accept any input valid for time.ParseDuration. + +The default set of command-line flags is controlled by +top-level functions. The FlagSet type allows one to define +independent sets of flags, such as to implement subcommands +in a command-line interface. The methods of FlagSet are +analogous to the top-level functions for the command-line +flag set. +*/ +package pflag + +import ( + "bytes" + "errors" + "fmt" + "io" + "os" + "sort" + "strings" +) + +// ErrHelp is the error returned if the flag -help is invoked but no such flag is defined. +var ErrHelp = errors.New("pflag: help requested") + +// ErrorHandling defines how to handle flag parsing errors. +type ErrorHandling int + +const ( + // ContinueOnError will return an err from Parse() if an error is found + ContinueOnError ErrorHandling = iota + // ExitOnError will call os.Exit(2) if an error is found when parsing + ExitOnError + // PanicOnError will panic() if an error is found when parsing flags + PanicOnError +) + +// NormalizedName is a flag name that has been normalized according to rules +// for the FlagSet (e.g. making '-' and '_' equivalent). +type NormalizedName string + +// A FlagSet represents a set of defined flags. +type FlagSet struct { + // Usage is the function called when an error occurs while parsing flags. + // The field is a function (not a method) that may be changed to point to + // a custom error handler. + Usage func() + + name string + parsed bool + actual map[NormalizedName]*Flag + formal map[NormalizedName]*Flag + shorthands map[byte]*Flag + args []string // arguments after flags + argsLenAtDash int // len(args) when a '--' was located when parsing, or -1 if no -- + exitOnError bool // does the program exit if there's an error? + errorHandling ErrorHandling + output io.Writer // nil means stderr; use out() accessor + interspersed bool // allow interspersed option/non-option args + normalizeNameFunc func(f *FlagSet, name string) NormalizedName +} + +// A Flag represents the state of a flag. +type Flag struct { + Name string // name as it appears on command line + Shorthand string // one-letter abbreviated flag + Usage string // help message + Value Value // value as set + DefValue string // default value (as text); for usage message + Changed bool // If the user set the value (or if left to default) + NoOptDefVal string //default value (as text); if the flag is on the command line without any options + Deprecated string // If this flag is deprecated, this string is the new or now thing to use + Hidden bool // used by cobra.Command to allow flags to be hidden from help/usage text + ShorthandDeprecated string // If the shorthand of this flag is deprecated, this string is the new or now thing to use + Annotations map[string][]string // used by cobra.Command bash autocomple code +} + +// Value is the interface to the dynamic value stored in a flag. +// (The default value is represented as a string.) +type Value interface { + String() string + Set(string) error + Type() string +} + +// sortFlags returns the flags as a slice in lexicographical sorted order. +func sortFlags(flags map[NormalizedName]*Flag) []*Flag { + list := make(sort.StringSlice, len(flags)) + i := 0 + for k := range flags { + list[i] = string(k) + i++ + } + list.Sort() + result := make([]*Flag, len(list)) + for i, name := range list { + result[i] = flags[NormalizedName(name)] + } + return result +} + +// SetNormalizeFunc allows you to add a function which can translate flag names. +// Flags added to the FlagSet will be translated and then when anything tries to +// look up the flag that will also be translated. So it would be possible to create +// a flag named "getURL" and have it translated to "geturl". A user could then pass +// "--getUrl" which may also be translated to "geturl" and everything will work. +func (f *FlagSet) SetNormalizeFunc(n func(f *FlagSet, name string) NormalizedName) { + f.normalizeNameFunc = n + for k, v := range f.formal { + delete(f.formal, k) + nname := f.normalizeFlagName(string(k)) + f.formal[nname] = v + v.Name = string(nname) + } +} + +// GetNormalizeFunc returns the previously set NormalizeFunc of a function which +// does no translation, if not set previously. +func (f *FlagSet) GetNormalizeFunc() func(f *FlagSet, name string) NormalizedName { + if f.normalizeNameFunc != nil { + return f.normalizeNameFunc + } + return func(f *FlagSet, name string) NormalizedName { return NormalizedName(name) } +} + +func (f *FlagSet) normalizeFlagName(name string) NormalizedName { + n := f.GetNormalizeFunc() + return n(f, name) +} + +func (f *FlagSet) out() io.Writer { + if f.output == nil { + return os.Stderr + } + return f.output +} + +// SetOutput sets the destination for usage and error messages. +// If output is nil, os.Stderr is used. +func (f *FlagSet) SetOutput(output io.Writer) { + f.output = output +} + +// VisitAll visits the flags in lexicographical order, calling fn for each. +// It visits all flags, even those not set. +func (f *FlagSet) VisitAll(fn func(*Flag)) { + for _, flag := range sortFlags(f.formal) { + fn(flag) + } +} + +// HasFlags returns a bool to indicate if the FlagSet has any flags definied. +func (f *FlagSet) HasFlags() bool { + return len(f.formal) > 0 +} + +// HasAvailableFlags returns a bool to indicate if the FlagSet has any flags +// definied that are not hidden or deprecated. +func (f *FlagSet) HasAvailableFlags() bool { + for _, flag := range f.formal { + if !flag.Hidden && len(flag.Deprecated) == 0 { + return true + } + } + return false +} + +// VisitAll visits the command-line flags in lexicographical order, calling +// fn for each. It visits all flags, even those not set. +func VisitAll(fn func(*Flag)) { + CommandLine.VisitAll(fn) +} + +// Visit visits the flags in lexicographical order, calling fn for each. +// It visits only those flags that have been set. +func (f *FlagSet) Visit(fn func(*Flag)) { + for _, flag := range sortFlags(f.actual) { + fn(flag) + } +} + +// Visit visits the command-line flags in lexicographical order, calling fn +// for each. It visits only those flags that have been set. +func Visit(fn func(*Flag)) { + CommandLine.Visit(fn) +} + +// Lookup returns the Flag structure of the named flag, returning nil if none exists. +func (f *FlagSet) Lookup(name string) *Flag { + return f.lookup(f.normalizeFlagName(name)) +} + +// lookup returns the Flag structure of the named flag, returning nil if none exists. +func (f *FlagSet) lookup(name NormalizedName) *Flag { + return f.formal[name] +} + +// func to return a given type for a given flag name +func (f *FlagSet) getFlagType(name string, ftype string, convFunc func(sval string) (interface{}, error)) (interface{}, error) { + flag := f.Lookup(name) + if flag == nil { + err := fmt.Errorf("flag accessed but not defined: %s", name) + return nil, err + } + + if flag.Value.Type() != ftype { + err := fmt.Errorf("trying to get %s value of flag of type %s", ftype, flag.Value.Type()) + return nil, err + } + + sval := flag.Value.String() + result, err := convFunc(sval) + if err != nil { + return nil, err + } + return result, nil +} + +// ArgsLenAtDash will return the length of f.Args at the moment when a -- was +// found during arg parsing. This allows your program to know which args were +// before the -- and which came after. +func (f *FlagSet) ArgsLenAtDash() int { + return f.argsLenAtDash +} + +// MarkDeprecated indicated that a flag is deprecated in your program. It will +// continue to function but will not show up in help or usage messages. Using +// this flag will also print the given usageMessage. +func (f *FlagSet) MarkDeprecated(name string, usageMessage string) error { + flag := f.Lookup(name) + if flag == nil { + return fmt.Errorf("flag %q does not exist", name) + } + if len(usageMessage) == 0 { + return fmt.Errorf("deprecated message for flag %q must be set", name) + } + flag.Deprecated = usageMessage + return nil +} + +// MarkShorthandDeprecated will mark the shorthand of a flag deprecated in your +// program. It will continue to function but will not show up in help or usage +// messages. Using this flag will also print the given usageMessage. +func (f *FlagSet) MarkShorthandDeprecated(name string, usageMessage string) error { + flag := f.Lookup(name) + if flag == nil { + return fmt.Errorf("flag %q does not exist", name) + } + if len(usageMessage) == 0 { + return fmt.Errorf("deprecated message for flag %q must be set", name) + } + flag.ShorthandDeprecated = usageMessage + return nil +} + +// MarkHidden sets a flag to 'hidden' in your program. It will continue to +// function but will not show up in help or usage messages. +func (f *FlagSet) MarkHidden(name string) error { + flag := f.Lookup(name) + if flag == nil { + return fmt.Errorf("flag %q does not exist", name) + } + flag.Hidden = true + return nil +} + +// Lookup returns the Flag structure of the named command-line flag, +// returning nil if none exists. +func Lookup(name string) *Flag { + return CommandLine.Lookup(name) +} + +// Set sets the value of the named flag. +func (f *FlagSet) Set(name, value string) error { + normalName := f.normalizeFlagName(name) + flag, ok := f.formal[normalName] + if !ok { + return fmt.Errorf("no such flag -%v", name) + } + err := flag.Value.Set(value) + if err != nil { + return err + } + if f.actual == nil { + f.actual = make(map[NormalizedName]*Flag) + } + f.actual[normalName] = flag + flag.Changed = true + if len(flag.Deprecated) > 0 { + fmt.Fprintf(os.Stderr, "Flag --%s has been deprecated, %s\n", flag.Name, flag.Deprecated) + } + return nil +} + +// SetAnnotation allows one to set arbitrary annotations on a flag in the FlagSet. +// This is sometimes used by spf13/cobra programs which want to generate additional +// bash completion information. +func (f *FlagSet) SetAnnotation(name, key string, values []string) error { + normalName := f.normalizeFlagName(name) + flag, ok := f.formal[normalName] + if !ok { + return fmt.Errorf("no such flag -%v", name) + } + if flag.Annotations == nil { + flag.Annotations = map[string][]string{} + } + flag.Annotations[key] = values + return nil +} + +// Changed returns true if the flag was explicitly set during Parse() and false +// otherwise +func (f *FlagSet) Changed(name string) bool { + flag := f.Lookup(name) + // If a flag doesn't exist, it wasn't changed.... + if flag == nil { + return false + } + return flag.Changed +} + +// Set sets the value of the named command-line flag. +func Set(name, value string) error { + return CommandLine.Set(name, value) +} + +// PrintDefaults prints, to standard error unless configured +// otherwise, the default values of all defined flags in the set. +func (f *FlagSet) PrintDefaults() { + usages := f.FlagUsages() + fmt.Fprintf(f.out(), "%s", usages) +} + +// isZeroValue guesses whether the string represents the zero +// value for a flag. It is not accurate but in practice works OK. +func isZeroValue(value string) bool { + switch value { + case "false": + return true + case "": + return true + case "": + return true + case "0": + return true + } + return false +} + +// UnquoteUsage extracts a back-quoted name from the usage +// string for a flag and returns it and the un-quoted usage. +// Given "a `name` to show" it returns ("name", "a name to show"). +// If there are no back quotes, the name is an educated guess of the +// type of the flag's value, or the empty string if the flag is boolean. +func UnquoteUsage(flag *Flag) (name string, usage string) { + // Look for a back-quoted name, but avoid the strings package. + usage = flag.Usage + for i := 0; i < len(usage); i++ { + if usage[i] == '`' { + for j := i + 1; j < len(usage); j++ { + if usage[j] == '`' { + name = usage[i+1 : j] + usage = usage[:i] + name + usage[j+1:] + return name, usage + } + } + break // Only one back quote; use type name. + } + } + // No explicit name, so use type if we can find one. + name = "value" + switch flag.Value.(type) { + case boolFlag: + name = "" + case *durationValue: + name = "duration" + case *float64Value: + name = "float" + case *intValue, *int64Value: + name = "int" + case *stringValue: + name = "string" + case *uintValue, *uint64Value: + name = "uint" + } + return +} + +// FlagUsages Returns a string containing the usage information for all flags in +// the FlagSet +func (f *FlagSet) FlagUsages() string { + x := new(bytes.Buffer) + + lines := make([]string, 0, len(f.formal)) + + maxlen := 0 + f.VisitAll(func(flag *Flag) { + if len(flag.Deprecated) > 0 || flag.Hidden { + return + } + + line := "" + if len(flag.Shorthand) > 0 && len(flag.ShorthandDeprecated) == 0 { + line = fmt.Sprintf(" -%s, --%s", flag.Shorthand, flag.Name) + } else { + line = fmt.Sprintf(" --%s", flag.Name) + } + + varname, usage := UnquoteUsage(flag) + if len(varname) > 0 { + line += " " + varname + } + if len(flag.NoOptDefVal) > 0 { + switch flag.Value.Type() { + case "string": + line += fmt.Sprintf("[=%q]", flag.NoOptDefVal) + case "bool": + if flag.NoOptDefVal != "true" { + line += fmt.Sprintf("[=%s]", flag.NoOptDefVal) + } + default: + line += fmt.Sprintf("[=%s]", flag.NoOptDefVal) + } + } + + // This special character will be replaced with spacing once the + // correct alignment is calculated + line += "\x00" + if len(line) > maxlen { + maxlen = len(line) + } + + line += usage + if !isZeroValue(flag.DefValue) { + if flag.Value.Type() == "string" { + line += fmt.Sprintf(" (default %q)", flag.DefValue) + } else { + line += fmt.Sprintf(" (default %s)", flag.DefValue) + } + } + + lines = append(lines, line) + }) + + for _, line := range lines { + sidx := strings.Index(line, "\x00") + spacing := strings.Repeat(" ", maxlen-sidx) + fmt.Fprintln(x, line[:sidx], spacing, line[sidx+1:]) + } + + return x.String() +} + +// PrintDefaults prints to standard error the default values of all defined command-line flags. +func PrintDefaults() { + CommandLine.PrintDefaults() +} + +// defaultUsage is the default function to print a usage message. +func defaultUsage(f *FlagSet) { + fmt.Fprintf(f.out(), "Usage of %s:\n", f.name) + f.PrintDefaults() +} + +// NOTE: Usage is not just defaultUsage(CommandLine) +// because it serves (via godoc flag Usage) as the example +// for how to write your own usage function. + +// Usage prints to standard error a usage message documenting all defined command-line flags. +// The function is a variable that may be changed to point to a custom function. +// By default it prints a simple header and calls PrintDefaults; for details about the +// format of the output and how to control it, see the documentation for PrintDefaults. +var Usage = func() { + fmt.Fprintf(os.Stderr, "Usage of %s:\n", os.Args[0]) + PrintDefaults() +} + +// NFlag returns the number of flags that have been set. +func (f *FlagSet) NFlag() int { return len(f.actual) } + +// NFlag returns the number of command-line flags that have been set. +func NFlag() int { return len(CommandLine.actual) } + +// Arg returns the i'th argument. Arg(0) is the first remaining argument +// after flags have been processed. +func (f *FlagSet) Arg(i int) string { + if i < 0 || i >= len(f.args) { + return "" + } + return f.args[i] +} + +// Arg returns the i'th command-line argument. Arg(0) is the first remaining argument +// after flags have been processed. +func Arg(i int) string { + return CommandLine.Arg(i) +} + +// NArg is the number of arguments remaining after flags have been processed. +func (f *FlagSet) NArg() int { return len(f.args) } + +// NArg is the number of arguments remaining after flags have been processed. +func NArg() int { return len(CommandLine.args) } + +// Args returns the non-flag arguments. +func (f *FlagSet) Args() []string { return f.args } + +// Args returns the non-flag command-line arguments. +func Args() []string { return CommandLine.args } + +// Var defines a flag with the specified name and usage string. The type and +// value of the flag are represented by the first argument, of type Value, which +// typically holds a user-defined implementation of Value. For instance, the +// caller could create a flag that turns a comma-separated string into a slice +// of strings by giving the slice the methods of Value; in particular, Set would +// decompose the comma-separated string into the slice. +func (f *FlagSet) Var(value Value, name string, usage string) { + f.VarP(value, name, "", usage) +} + +// VarPF is like VarP, but returns the flag created +func (f *FlagSet) VarPF(value Value, name, shorthand, usage string) *Flag { + // Remember the default value as a string; it won't change. + flag := &Flag{ + Name: name, + Shorthand: shorthand, + Usage: usage, + Value: value, + DefValue: value.String(), + } + f.AddFlag(flag) + return flag +} + +// VarP is like Var, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) VarP(value Value, name, shorthand, usage string) { + _ = f.VarPF(value, name, shorthand, usage) +} + +// AddFlag will add the flag to the FlagSet +func (f *FlagSet) AddFlag(flag *Flag) { + // Call normalizeFlagName function only once + normalizedFlagName := f.normalizeFlagName(flag.Name) + + _, alreadythere := f.formal[normalizedFlagName] + if alreadythere { + msg := fmt.Sprintf("%s flag redefined: %s", f.name, flag.Name) + fmt.Fprintln(f.out(), msg) + panic(msg) // Happens only if flags are declared with identical names + } + if f.formal == nil { + f.formal = make(map[NormalizedName]*Flag) + } + + flag.Name = string(normalizedFlagName) + f.formal[normalizedFlagName] = flag + + if len(flag.Shorthand) == 0 { + return + } + if len(flag.Shorthand) > 1 { + fmt.Fprintf(f.out(), "%s shorthand more than ASCII character: %s\n", f.name, flag.Shorthand) + panic("shorthand is more than one character") + } + if f.shorthands == nil { + f.shorthands = make(map[byte]*Flag) + } + c := flag.Shorthand[0] + old, alreadythere := f.shorthands[c] + if alreadythere { + fmt.Fprintf(f.out(), "%s shorthand reused: %q for %s already used for %s\n", f.name, c, flag.Name, old.Name) + panic("shorthand redefinition") + } + f.shorthands[c] = flag +} + +// AddFlagSet adds one FlagSet to another. If a flag is already present in f +// the flag from newSet will be ignored +func (f *FlagSet) AddFlagSet(newSet *FlagSet) { + if newSet == nil { + return + } + newSet.VisitAll(func(flag *Flag) { + if f.Lookup(flag.Name) == nil { + f.AddFlag(flag) + } + }) +} + +// Var defines a flag with the specified name and usage string. The type and +// value of the flag are represented by the first argument, of type Value, which +// typically holds a user-defined implementation of Value. For instance, the +// caller could create a flag that turns a comma-separated string into a slice +// of strings by giving the slice the methods of Value; in particular, Set would +// decompose the comma-separated string into the slice. +func Var(value Value, name string, usage string) { + CommandLine.VarP(value, name, "", usage) +} + +// VarP is like Var, but accepts a shorthand letter that can be used after a single dash. +func VarP(value Value, name, shorthand, usage string) { + CommandLine.VarP(value, name, shorthand, usage) +} + +// failf prints to standard error a formatted error and usage message and +// returns the error. +func (f *FlagSet) failf(format string, a ...interface{}) error { + err := fmt.Errorf(format, a...) + fmt.Fprintln(f.out(), err) + f.usage() + return err +} + +// usage calls the Usage method for the flag set, or the usage function if +// the flag set is CommandLine. +func (f *FlagSet) usage() { + if f == CommandLine { + Usage() + } else if f.Usage == nil { + defaultUsage(f) + } else { + f.Usage() + } +} + +func (f *FlagSet) setFlag(flag *Flag, value string, origArg string) error { + if err := flag.Value.Set(value); err != nil { + return f.failf("invalid argument %q for %s: %v", value, origArg, err) + } + // mark as visited for Visit() + if f.actual == nil { + f.actual = make(map[NormalizedName]*Flag) + } + f.actual[f.normalizeFlagName(flag.Name)] = flag + flag.Changed = true + if len(flag.Deprecated) > 0 { + fmt.Fprintf(os.Stderr, "Flag --%s has been deprecated, %s\n", flag.Name, flag.Deprecated) + } + if len(flag.ShorthandDeprecated) > 0 && containsShorthand(origArg, flag.Shorthand) { + fmt.Fprintf(os.Stderr, "Flag shorthand -%s has been deprecated, %s\n", flag.Shorthand, flag.ShorthandDeprecated) + } + return nil +} + +func containsShorthand(arg, shorthand string) bool { + // filter out flags -- + if strings.HasPrefix(arg, "-") { + return false + } + arg = strings.SplitN(arg, "=", 2)[0] + return strings.Contains(arg, shorthand) +} + +func (f *FlagSet) parseLongArg(s string, args []string) (a []string, err error) { + a = args + name := s[2:] + if len(name) == 0 || name[0] == '-' || name[0] == '=' { + err = f.failf("bad flag syntax: %s", s) + return + } + split := strings.SplitN(name, "=", 2) + name = split[0] + flag, alreadythere := f.formal[f.normalizeFlagName(name)] + if !alreadythere { + if name == "help" { // special case for nice help message. + f.usage() + return a, ErrHelp + } + err = f.failf("unknown flag: --%s", name) + return + } + var value string + if len(split) == 2 { + // '--flag=arg' + value = split[1] + } else if len(flag.NoOptDefVal) > 0 { + // '--flag' (arg was optional) + value = flag.NoOptDefVal + } else if len(a) > 0 { + // '--flag arg' + value = a[0] + a = a[1:] + } else { + // '--flag' (arg was required) + err = f.failf("flag needs an argument: %s", s) + return + } + err = f.setFlag(flag, value, s) + return +} + +func (f *FlagSet) parseSingleShortArg(shorthands string, args []string) (outShorts string, outArgs []string, err error) { + if strings.HasPrefix(shorthands, "test.") { + return + } + outArgs = args + outShorts = shorthands[1:] + c := shorthands[0] + + flag, alreadythere := f.shorthands[c] + if !alreadythere { + if c == 'h' { // special case for nice help message. + f.usage() + err = ErrHelp + return + } + //TODO continue on error + err = f.failf("unknown shorthand flag: %q in -%s", c, shorthands) + return + } + var value string + if len(shorthands) > 2 && shorthands[1] == '=' { + value = shorthands[2:] + outShorts = "" + } else if len(flag.NoOptDefVal) > 0 { + value = flag.NoOptDefVal + } else if len(shorthands) > 1 { + value = shorthands[1:] + outShorts = "" + } else if len(args) > 0 { + value = args[0] + outArgs = args[1:] + } else { + err = f.failf("flag needs an argument: %q in -%s", c, shorthands) + return + } + err = f.setFlag(flag, value, shorthands) + return +} + +func (f *FlagSet) parseShortArg(s string, args []string) (a []string, err error) { + a = args + shorthands := s[1:] + + for len(shorthands) > 0 { + shorthands, a, err = f.parseSingleShortArg(shorthands, args) + if err != nil { + return + } + } + + return +} + +func (f *FlagSet) parseArgs(args []string) (err error) { + for len(args) > 0 { + s := args[0] + args = args[1:] + if len(s) == 0 || s[0] != '-' || len(s) == 1 { + if !f.interspersed { + f.args = append(f.args, s) + f.args = append(f.args, args...) + return nil + } + f.args = append(f.args, s) + continue + } + + if s[1] == '-' { + if len(s) == 2 { // "--" terminates the flags + f.argsLenAtDash = len(f.args) + f.args = append(f.args, args...) + break + } + args, err = f.parseLongArg(s, args) + } else { + args, err = f.parseShortArg(s, args) + } + if err != nil { + return + } + } + return +} + +// Parse parses flag definitions from the argument list, which should not +// include the command name. Must be called after all flags in the FlagSet +// are defined and before flags are accessed by the program. +// The return value will be ErrHelp if -help was set but not defined. +func (f *FlagSet) Parse(arguments []string) error { + f.parsed = true + f.args = make([]string, 0, len(arguments)) + err := f.parseArgs(arguments) + if err != nil { + switch f.errorHandling { + case ContinueOnError: + return err + case ExitOnError: + os.Exit(2) + case PanicOnError: + panic(err) + } + } + return nil +} + +// Parsed reports whether f.Parse has been called. +func (f *FlagSet) Parsed() bool { + return f.parsed +} + +// Parse parses the command-line flags from os.Args[1:]. Must be called +// after all flags are defined and before flags are accessed by the program. +func Parse() { + // Ignore errors; CommandLine is set for ExitOnError. + CommandLine.Parse(os.Args[1:]) +} + +// SetInterspersed sets whether to support interspersed option/non-option arguments. +func SetInterspersed(interspersed bool) { + CommandLine.SetInterspersed(interspersed) +} + +// Parsed returns true if the command-line flags have been parsed. +func Parsed() bool { + return CommandLine.Parsed() +} + +// CommandLine is the default set of command-line flags, parsed from os.Args. +var CommandLine = NewFlagSet(os.Args[0], ExitOnError) + +// NewFlagSet returns a new, empty flag set with the specified name and +// error handling property. +func NewFlagSet(name string, errorHandling ErrorHandling) *FlagSet { + f := &FlagSet{ + name: name, + errorHandling: errorHandling, + argsLenAtDash: -1, + interspersed: true, + } + return f +} + +// SetInterspersed sets whether to support interspersed option/non-option arguments. +func (f *FlagSet) SetInterspersed(interspersed bool) { + f.interspersed = interspersed +} + +// Init sets the name and error handling property for a flag set. +// By default, the zero FlagSet uses an empty name and the +// ContinueOnError error handling policy. +func (f *FlagSet) Init(name string, errorHandling ErrorHandling) { + f.name = name + f.errorHandling = errorHandling + f.argsLenAtDash = -1 +} diff --git a/vendor/github.com/spf13/pflag/flag_test.go b/vendor/github.com/spf13/pflag/flag_test.go new file mode 100644 index 000000000..0ae2e4ff1 --- /dev/null +++ b/vendor/github.com/spf13/pflag/flag_test.go @@ -0,0 +1,913 @@ +// Copyright 2009 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package pflag + +import ( + "bytes" + "fmt" + "io" + "io/ioutil" + "net" + "os" + "reflect" + "sort" + "strings" + "testing" + "time" +) + +var ( + testBool = Bool("test_bool", false, "bool value") + testInt = Int("test_int", 0, "int value") + testInt64 = Int64("test_int64", 0, "int64 value") + testUint = Uint("test_uint", 0, "uint value") + testUint64 = Uint64("test_uint64", 0, "uint64 value") + testString = String("test_string", "0", "string value") + testFloat = Float64("test_float64", 0, "float64 value") + testDuration = Duration("test_duration", 0, "time.Duration value") + testOptionalInt = Int("test_optional_int", 0, "optional int value") + normalizeFlagNameInvocations = 0 +) + +func boolString(s string) string { + if s == "0" { + return "false" + } + return "true" +} + +func TestEverything(t *testing.T) { + m := make(map[string]*Flag) + desired := "0" + visitor := func(f *Flag) { + if len(f.Name) > 5 && f.Name[0:5] == "test_" { + m[f.Name] = f + ok := false + switch { + case f.Value.String() == desired: + ok = true + case f.Name == "test_bool" && f.Value.String() == boolString(desired): + ok = true + case f.Name == "test_duration" && f.Value.String() == desired+"s": + ok = true + } + if !ok { + t.Error("Visit: bad value", f.Value.String(), "for", f.Name) + } + } + } + VisitAll(visitor) + if len(m) != 9 { + t.Error("VisitAll misses some flags") + for k, v := range m { + t.Log(k, *v) + } + } + m = make(map[string]*Flag) + Visit(visitor) + if len(m) != 0 { + t.Errorf("Visit sees unset flags") + for k, v := range m { + t.Log(k, *v) + } + } + // Now set all flags + Set("test_bool", "true") + Set("test_int", "1") + Set("test_int64", "1") + Set("test_uint", "1") + Set("test_uint64", "1") + Set("test_string", "1") + Set("test_float64", "1") + Set("test_duration", "1s") + Set("test_optional_int", "1") + desired = "1" + Visit(visitor) + if len(m) != 9 { + t.Error("Visit fails after set") + for k, v := range m { + t.Log(k, *v) + } + } + // Now test they're visited in sort order. + var flagNames []string + Visit(func(f *Flag) { flagNames = append(flagNames, f.Name) }) + if !sort.StringsAreSorted(flagNames) { + t.Errorf("flag names not sorted: %v", flagNames) + } +} + +func TestUsage(t *testing.T) { + called := false + ResetForTesting(func() { called = true }) + if GetCommandLine().Parse([]string{"--x"}) == nil { + t.Error("parse did not fail for unknown flag") + } + if !called { + t.Error("did not call Usage for unknown flag") + } +} + +func TestAddFlagSet(t *testing.T) { + oldSet := NewFlagSet("old", ContinueOnError) + newSet := NewFlagSet("new", ContinueOnError) + + oldSet.String("flag1", "flag1", "flag1") + oldSet.String("flag2", "flag2", "flag2") + + newSet.String("flag2", "flag2", "flag2") + newSet.String("flag3", "flag3", "flag3") + + oldSet.AddFlagSet(newSet) + + if len(oldSet.formal) != 3 { + t.Errorf("Unexpected result adding a FlagSet to a FlagSet %v", oldSet) + } +} + +func TestAnnotation(t *testing.T) { + f := NewFlagSet("shorthand", ContinueOnError) + + if err := f.SetAnnotation("missing-flag", "key", nil); err == nil { + t.Errorf("Expected error setting annotation on non-existent flag") + } + + f.StringP("stringa", "a", "", "string value") + if err := f.SetAnnotation("stringa", "key", nil); err != nil { + t.Errorf("Unexpected error setting new nil annotation: %v", err) + } + if annotation := f.Lookup("stringa").Annotations["key"]; annotation != nil { + t.Errorf("Unexpected annotation: %v", annotation) + } + + f.StringP("stringb", "b", "", "string2 value") + if err := f.SetAnnotation("stringb", "key", []string{"value1"}); err != nil { + t.Errorf("Unexpected error setting new annotation: %v", err) + } + if annotation := f.Lookup("stringb").Annotations["key"]; !reflect.DeepEqual(annotation, []string{"value1"}) { + t.Errorf("Unexpected annotation: %v", annotation) + } + + if err := f.SetAnnotation("stringb", "key", []string{"value2"}); err != nil { + t.Errorf("Unexpected error updating annotation: %v", err) + } + if annotation := f.Lookup("stringb").Annotations["key"]; !reflect.DeepEqual(annotation, []string{"value2"}) { + t.Errorf("Unexpected annotation: %v", annotation) + } +} + +func testParse(f *FlagSet, t *testing.T) { + if f.Parsed() { + t.Error("f.Parse() = true before Parse") + } + boolFlag := f.Bool("bool", false, "bool value") + bool2Flag := f.Bool("bool2", false, "bool2 value") + bool3Flag := f.Bool("bool3", false, "bool3 value") + intFlag := f.Int("int", 0, "int value") + int8Flag := f.Int8("int8", 0, "int value") + int32Flag := f.Int32("int32", 0, "int value") + int64Flag := f.Int64("int64", 0, "int64 value") + uintFlag := f.Uint("uint", 0, "uint value") + uint8Flag := f.Uint8("uint8", 0, "uint value") + uint16Flag := f.Uint16("uint16", 0, "uint value") + uint32Flag := f.Uint32("uint32", 0, "uint value") + uint64Flag := f.Uint64("uint64", 0, "uint64 value") + stringFlag := f.String("string", "0", "string value") + float32Flag := f.Float32("float32", 0, "float32 value") + float64Flag := f.Float64("float64", 0, "float64 value") + ipFlag := f.IP("ip", net.ParseIP("127.0.0.1"), "ip value") + maskFlag := f.IPMask("mask", ParseIPv4Mask("0.0.0.0"), "mask value") + durationFlag := f.Duration("duration", 5*time.Second, "time.Duration value") + optionalIntNoValueFlag := f.Int("optional-int-no-value", 0, "int value") + f.Lookup("optional-int-no-value").NoOptDefVal = "9" + optionalIntWithValueFlag := f.Int("optional-int-with-value", 0, "int value") + f.Lookup("optional-int-no-value").NoOptDefVal = "9" + extra := "one-extra-argument" + args := []string{ + "--bool", + "--bool2=true", + "--bool3=false", + "--int=22", + "--int8=-8", + "--int32=-32", + "--int64=0x23", + "--uint", "24", + "--uint8=8", + "--uint16=16", + "--uint32=32", + "--uint64=25", + "--string=hello", + "--float32=-172e12", + "--float64=2718e28", + "--ip=10.11.12.13", + "--mask=255.255.255.0", + "--duration=2m", + "--optional-int-no-value", + "--optional-int-with-value=42", + extra, + } + if err := f.Parse(args); err != nil { + t.Fatal(err) + } + if !f.Parsed() { + t.Error("f.Parse() = false after Parse") + } + if *boolFlag != true { + t.Error("bool flag should be true, is ", *boolFlag) + } + if v, err := f.GetBool("bool"); err != nil || v != *boolFlag { + t.Error("GetBool does not work.") + } + if *bool2Flag != true { + t.Error("bool2 flag should be true, is ", *bool2Flag) + } + if *bool3Flag != false { + t.Error("bool3 flag should be false, is ", *bool2Flag) + } + if *intFlag != 22 { + t.Error("int flag should be 22, is ", *intFlag) + } + if v, err := f.GetInt("int"); err != nil || v != *intFlag { + t.Error("GetInt does not work.") + } + if *int8Flag != -8 { + t.Error("int8 flag should be 0x23, is ", *int8Flag) + } + if v, err := f.GetInt8("int8"); err != nil || v != *int8Flag { + t.Error("GetInt8 does not work.") + } + if *int32Flag != -32 { + t.Error("int32 flag should be 0x23, is ", *int32Flag) + } + if v, err := f.GetInt32("int32"); err != nil || v != *int32Flag { + t.Error("GetInt32 does not work.") + } + if *int64Flag != 0x23 { + t.Error("int64 flag should be 0x23, is ", *int64Flag) + } + if v, err := f.GetInt64("int64"); err != nil || v != *int64Flag { + t.Error("GetInt64 does not work.") + } + if *uintFlag != 24 { + t.Error("uint flag should be 24, is ", *uintFlag) + } + if v, err := f.GetUint("uint"); err != nil || v != *uintFlag { + t.Error("GetUint does not work.") + } + if *uint8Flag != 8 { + t.Error("uint8 flag should be 8, is ", *uint8Flag) + } + if v, err := f.GetUint8("uint8"); err != nil || v != *uint8Flag { + t.Error("GetUint8 does not work.") + } + if *uint16Flag != 16 { + t.Error("uint16 flag should be 16, is ", *uint16Flag) + } + if v, err := f.GetUint16("uint16"); err != nil || v != *uint16Flag { + t.Error("GetUint16 does not work.") + } + if *uint32Flag != 32 { + t.Error("uint32 flag should be 32, is ", *uint32Flag) + } + if v, err := f.GetUint32("uint32"); err != nil || v != *uint32Flag { + t.Error("GetUint32 does not work.") + } + if *uint64Flag != 25 { + t.Error("uint64 flag should be 25, is ", *uint64Flag) + } + if v, err := f.GetUint64("uint64"); err != nil || v != *uint64Flag { + t.Error("GetUint64 does not work.") + } + if *stringFlag != "hello" { + t.Error("string flag should be `hello`, is ", *stringFlag) + } + if v, err := f.GetString("string"); err != nil || v != *stringFlag { + t.Error("GetString does not work.") + } + if *float32Flag != -172e12 { + t.Error("float32 flag should be -172e12, is ", *float32Flag) + } + if v, err := f.GetFloat32("float32"); err != nil || v != *float32Flag { + t.Errorf("GetFloat32 returned %v but float32Flag was %v", v, *float32Flag) + } + if *float64Flag != 2718e28 { + t.Error("float64 flag should be 2718e28, is ", *float64Flag) + } + if v, err := f.GetFloat64("float64"); err != nil || v != *float64Flag { + t.Errorf("GetFloat64 returned %v but float64Flag was %v", v, *float64Flag) + } + if !(*ipFlag).Equal(net.ParseIP("10.11.12.13")) { + t.Error("ip flag should be 10.11.12.13, is ", *ipFlag) + } + if v, err := f.GetIP("ip"); err != nil || !v.Equal(*ipFlag) { + t.Errorf("GetIP returned %v but ipFlag was %v", v, *ipFlag) + } + if (*maskFlag).String() != ParseIPv4Mask("255.255.255.0").String() { + t.Error("mask flag should be 255.255.255.0, is ", (*maskFlag).String()) + } + if v, err := f.GetIPv4Mask("mask"); err != nil || v.String() != (*maskFlag).String() { + t.Errorf("GetIP returned %v maskFlag was %v error was %v", v, *maskFlag, err) + } + if *durationFlag != 2*time.Minute { + t.Error("duration flag should be 2m, is ", *durationFlag) + } + if v, err := f.GetDuration("duration"); err != nil || v != *durationFlag { + t.Error("GetDuration does not work.") + } + if _, err := f.GetInt("duration"); err == nil { + t.Error("GetInt parsed a time.Duration?!?!") + } + if *optionalIntNoValueFlag != 9 { + t.Error("optional int flag should be the default value, is ", *optionalIntNoValueFlag) + } + if *optionalIntWithValueFlag != 42 { + t.Error("optional int flag should be 42, is ", *optionalIntWithValueFlag) + } + if len(f.Args()) != 1 { + t.Error("expected one argument, got", len(f.Args())) + } else if f.Args()[0] != extra { + t.Errorf("expected argument %q got %q", extra, f.Args()[0]) + } +} + +func TestShorthand(t *testing.T) { + f := NewFlagSet("shorthand", ContinueOnError) + if f.Parsed() { + t.Error("f.Parse() = true before Parse") + } + boolaFlag := f.BoolP("boola", "a", false, "bool value") + boolbFlag := f.BoolP("boolb", "b", false, "bool2 value") + boolcFlag := f.BoolP("boolc", "c", false, "bool3 value") + booldFlag := f.BoolP("boold", "d", false, "bool4 value") + stringaFlag := f.StringP("stringa", "s", "0", "string value") + stringzFlag := f.StringP("stringz", "z", "0", "string value") + extra := "interspersed-argument" + notaflag := "--i-look-like-a-flag" + args := []string{ + "-ab", + extra, + "-cs", + "hello", + "-z=something", + "-d=true", + "--", + notaflag, + } + f.SetOutput(ioutil.Discard) + if err := f.Parse(args); err != nil { + t.Error("expected no error, got ", err) + } + if !f.Parsed() { + t.Error("f.Parse() = false after Parse") + } + if *boolaFlag != true { + t.Error("boola flag should be true, is ", *boolaFlag) + } + if *boolbFlag != true { + t.Error("boolb flag should be true, is ", *boolbFlag) + } + if *boolcFlag != true { + t.Error("boolc flag should be true, is ", *boolcFlag) + } + if *booldFlag != true { + t.Error("boold flag should be true, is ", *booldFlag) + } + if *stringaFlag != "hello" { + t.Error("stringa flag should be `hello`, is ", *stringaFlag) + } + if *stringzFlag != "something" { + t.Error("stringz flag should be `something`, is ", *stringzFlag) + } + if len(f.Args()) != 2 { + t.Error("expected one argument, got", len(f.Args())) + } else if f.Args()[0] != extra { + t.Errorf("expected argument %q got %q", extra, f.Args()[0]) + } else if f.Args()[1] != notaflag { + t.Errorf("expected argument %q got %q", notaflag, f.Args()[1]) + } + if f.ArgsLenAtDash() != 1 { + t.Errorf("expected argsLenAtDash %d got %d", f.ArgsLenAtDash(), 1) + } +} + +func TestParse(t *testing.T) { + ResetForTesting(func() { t.Error("bad parse") }) + testParse(GetCommandLine(), t) +} + +func TestFlagSetParse(t *testing.T) { + testParse(NewFlagSet("test", ContinueOnError), t) +} + +func TestChangedHelper(t *testing.T) { + f := NewFlagSet("changedtest", ContinueOnError) + _ = f.Bool("changed", false, "changed bool") + _ = f.Bool("settrue", true, "true to true") + _ = f.Bool("setfalse", false, "false to false") + _ = f.Bool("unchanged", false, "unchanged bool") + + args := []string{"--changed", "--settrue", "--setfalse=false"} + if err := f.Parse(args); err != nil { + t.Error("f.Parse() = false after Parse") + } + if !f.Changed("changed") { + t.Errorf("--changed wasn't changed!") + } + if !f.Changed("settrue") { + t.Errorf("--settrue wasn't changed!") + } + if !f.Changed("setfalse") { + t.Errorf("--setfalse wasn't changed!") + } + if f.Changed("unchanged") { + t.Errorf("--unchanged was changed!") + } + if f.Changed("invalid") { + t.Errorf("--invalid was changed!") + } + if f.ArgsLenAtDash() != -1 { + t.Errorf("Expected argsLenAtDash: %d but got %d", -1, f.ArgsLenAtDash()) + } +} + +func replaceSeparators(name string, from []string, to string) string { + result := name + for _, sep := range from { + result = strings.Replace(result, sep, to, -1) + } + // Type convert to indicate normalization has been done. + return result +} + +func wordSepNormalizeFunc(f *FlagSet, name string) NormalizedName { + seps := []string{"-", "_"} + name = replaceSeparators(name, seps, ".") + normalizeFlagNameInvocations++ + + return NormalizedName(name) +} + +func testWordSepNormalizedNames(args []string, t *testing.T) { + f := NewFlagSet("normalized", ContinueOnError) + if f.Parsed() { + t.Error("f.Parse() = true before Parse") + } + withDashFlag := f.Bool("with-dash-flag", false, "bool value") + // Set this after some flags have been added and before others. + f.SetNormalizeFunc(wordSepNormalizeFunc) + withUnderFlag := f.Bool("with_under_flag", false, "bool value") + withBothFlag := f.Bool("with-both_flag", false, "bool value") + if err := f.Parse(args); err != nil { + t.Fatal(err) + } + if !f.Parsed() { + t.Error("f.Parse() = false after Parse") + } + if *withDashFlag != true { + t.Error("withDashFlag flag should be true, is ", *withDashFlag) + } + if *withUnderFlag != true { + t.Error("withUnderFlag flag should be true, is ", *withUnderFlag) + } + if *withBothFlag != true { + t.Error("withBothFlag flag should be true, is ", *withBothFlag) + } +} + +func TestWordSepNormalizedNames(t *testing.T) { + args := []string{ + "--with-dash-flag", + "--with-under-flag", + "--with-both-flag", + } + testWordSepNormalizedNames(args, t) + + args = []string{ + "--with_dash_flag", + "--with_under_flag", + "--with_both_flag", + } + testWordSepNormalizedNames(args, t) + + args = []string{ + "--with-dash_flag", + "--with-under_flag", + "--with-both_flag", + } + testWordSepNormalizedNames(args, t) +} + +func aliasAndWordSepFlagNames(f *FlagSet, name string) NormalizedName { + seps := []string{"-", "_"} + + oldName := replaceSeparators("old-valid_flag", seps, ".") + newName := replaceSeparators("valid-flag", seps, ".") + + name = replaceSeparators(name, seps, ".") + switch name { + case oldName: + name = newName + break + } + + return NormalizedName(name) +} + +func TestCustomNormalizedNames(t *testing.T) { + f := NewFlagSet("normalized", ContinueOnError) + if f.Parsed() { + t.Error("f.Parse() = true before Parse") + } + + validFlag := f.Bool("valid-flag", false, "bool value") + f.SetNormalizeFunc(aliasAndWordSepFlagNames) + someOtherFlag := f.Bool("some-other-flag", false, "bool value") + + args := []string{"--old_valid_flag", "--some-other_flag"} + if err := f.Parse(args); err != nil { + t.Fatal(err) + } + + if *validFlag != true { + t.Errorf("validFlag is %v even though we set the alias --old_valid_falg", *validFlag) + } + if *someOtherFlag != true { + t.Error("someOtherFlag should be true, is ", *someOtherFlag) + } +} + +// Every flag we add, the name (displayed also in usage) should normalized +func TestNormalizationFuncShouldChangeFlagName(t *testing.T) { + // Test normalization after addition + f := NewFlagSet("normalized", ContinueOnError) + + f.Bool("valid_flag", false, "bool value") + if f.Lookup("valid_flag").Name != "valid_flag" { + t.Error("The new flag should have the name 'valid_flag' instead of ", f.Lookup("valid_flag").Name) + } + + f.SetNormalizeFunc(wordSepNormalizeFunc) + if f.Lookup("valid_flag").Name != "valid.flag" { + t.Error("The new flag should have the name 'valid.flag' instead of ", f.Lookup("valid_flag").Name) + } + + // Test normalization before addition + f = NewFlagSet("normalized", ContinueOnError) + f.SetNormalizeFunc(wordSepNormalizeFunc) + + f.Bool("valid_flag", false, "bool value") + if f.Lookup("valid_flag").Name != "valid.flag" { + t.Error("The new flag should have the name 'valid.flag' instead of ", f.Lookup("valid_flag").Name) + } +} + +// Declare a user-defined flag type. +type flagVar []string + +func (f *flagVar) String() string { + return fmt.Sprint([]string(*f)) +} + +func (f *flagVar) Set(value string) error { + *f = append(*f, value) + return nil +} + +func (f *flagVar) Type() string { + return "flagVar" +} + +func TestUserDefined(t *testing.T) { + var flags FlagSet + flags.Init("test", ContinueOnError) + var v flagVar + flags.VarP(&v, "v", "v", "usage") + if err := flags.Parse([]string{"--v=1", "-v2", "-v", "3"}); err != nil { + t.Error(err) + } + if len(v) != 3 { + t.Fatal("expected 3 args; got ", len(v)) + } + expect := "[1 2 3]" + if v.String() != expect { + t.Errorf("expected value %q got %q", expect, v.String()) + } +} + +func TestSetOutput(t *testing.T) { + var flags FlagSet + var buf bytes.Buffer + flags.SetOutput(&buf) + flags.Init("test", ContinueOnError) + flags.Parse([]string{"--unknown"}) + if out := buf.String(); !strings.Contains(out, "--unknown") { + t.Logf("expected output mentioning unknown; got %q", out) + } +} + +// This tests that one can reset the flags. This still works but not well, and is +// superseded by FlagSet. +func TestChangingArgs(t *testing.T) { + ResetForTesting(func() { t.Fatal("bad parse") }) + oldArgs := os.Args + defer func() { os.Args = oldArgs }() + os.Args = []string{"cmd", "--before", "subcmd"} + before := Bool("before", false, "") + if err := GetCommandLine().Parse(os.Args[1:]); err != nil { + t.Fatal(err) + } + cmd := Arg(0) + os.Args = []string{"subcmd", "--after", "args"} + after := Bool("after", false, "") + Parse() + args := Args() + + if !*before || cmd != "subcmd" || !*after || len(args) != 1 || args[0] != "args" { + t.Fatalf("expected true subcmd true [args] got %v %v %v %v", *before, cmd, *after, args) + } +} + +// Test that -help invokes the usage message and returns ErrHelp. +func TestHelp(t *testing.T) { + var helpCalled = false + fs := NewFlagSet("help test", ContinueOnError) + fs.Usage = func() { helpCalled = true } + var flag bool + fs.BoolVar(&flag, "flag", false, "regular flag") + // Regular flag invocation should work + err := fs.Parse([]string{"--flag=true"}) + if err != nil { + t.Fatal("expected no error; got ", err) + } + if !flag { + t.Error("flag was not set by --flag") + } + if helpCalled { + t.Error("help called for regular flag") + helpCalled = false // reset for next test + } + // Help flag should work as expected. + err = fs.Parse([]string{"--help"}) + if err == nil { + t.Fatal("error expected") + } + if err != ErrHelp { + t.Fatal("expected ErrHelp; got ", err) + } + if !helpCalled { + t.Fatal("help was not called") + } + // If we define a help flag, that should override. + var help bool + fs.BoolVar(&help, "help", false, "help flag") + helpCalled = false + err = fs.Parse([]string{"--help"}) + if err != nil { + t.Fatal("expected no error for defined --help; got ", err) + } + if helpCalled { + t.Fatal("help was called; should not have been for defined help flag") + } +} + +func TestNoInterspersed(t *testing.T) { + f := NewFlagSet("test", ContinueOnError) + f.SetInterspersed(false) + f.Bool("true", true, "always true") + f.Bool("false", false, "always false") + err := f.Parse([]string{"--true", "break", "--false"}) + if err != nil { + t.Fatal("expected no error; got ", err) + } + args := f.Args() + if len(args) != 2 || args[0] != "break" || args[1] != "--false" { + t.Fatal("expected interspersed options/non-options to fail") + } +} + +func TestTermination(t *testing.T) { + f := NewFlagSet("termination", ContinueOnError) + boolFlag := f.BoolP("bool", "l", false, "bool value") + if f.Parsed() { + t.Error("f.Parse() = true before Parse") + } + arg1 := "ls" + arg2 := "-l" + args := []string{ + "--", + arg1, + arg2, + } + f.SetOutput(ioutil.Discard) + if err := f.Parse(args); err != nil { + t.Fatal("expected no error; got ", err) + } + if !f.Parsed() { + t.Error("f.Parse() = false after Parse") + } + if *boolFlag { + t.Error("expected boolFlag=false, got true") + } + if len(f.Args()) != 2 { + t.Errorf("expected 2 arguments, got %d: %v", len(f.Args()), f.Args()) + } + if f.Args()[0] != arg1 { + t.Errorf("expected argument %q got %q", arg1, f.Args()[0]) + } + if f.Args()[1] != arg2 { + t.Errorf("expected argument %q got %q", arg2, f.Args()[1]) + } + if f.ArgsLenAtDash() != 0 { + t.Errorf("expected argsLenAtDash %d got %d", 0, f.ArgsLenAtDash()) + } +} + +func TestDeprecatedFlagInDocs(t *testing.T) { + f := NewFlagSet("bob", ContinueOnError) + f.Bool("badflag", true, "always true") + f.MarkDeprecated("badflag", "use --good-flag instead") + + out := new(bytes.Buffer) + f.SetOutput(out) + f.PrintDefaults() + + if strings.Contains(out.String(), "badflag") { + t.Errorf("found deprecated flag in usage!") + } +} + +func TestDeprecatedFlagShorthandInDocs(t *testing.T) { + f := NewFlagSet("bob", ContinueOnError) + name := "noshorthandflag" + f.BoolP(name, "n", true, "always true") + f.MarkShorthandDeprecated("noshorthandflag", fmt.Sprintf("use --%s instead", name)) + + out := new(bytes.Buffer) + f.SetOutput(out) + f.PrintDefaults() + + if strings.Contains(out.String(), "-n,") { + t.Errorf("found deprecated flag shorthand in usage!") + } +} + +func parseReturnStderr(t *testing.T, f *FlagSet, args []string) (string, error) { + oldStderr := os.Stderr + r, w, _ := os.Pipe() + os.Stderr = w + + err := f.Parse(args) + + outC := make(chan string) + // copy the output in a separate goroutine so printing can't block indefinitely + go func() { + var buf bytes.Buffer + io.Copy(&buf, r) + outC <- buf.String() + }() + + w.Close() + os.Stderr = oldStderr + out := <-outC + + return out, err +} + +func TestDeprecatedFlagUsage(t *testing.T) { + f := NewFlagSet("bob", ContinueOnError) + f.Bool("badflag", true, "always true") + usageMsg := "use --good-flag instead" + f.MarkDeprecated("badflag", usageMsg) + + args := []string{"--badflag"} + out, err := parseReturnStderr(t, f, args) + if err != nil { + t.Fatal("expected no error; got ", err) + } + + if !strings.Contains(out, usageMsg) { + t.Errorf("usageMsg not printed when using a deprecated flag!") + } +} + +func TestDeprecatedFlagShorthandUsage(t *testing.T) { + f := NewFlagSet("bob", ContinueOnError) + name := "noshorthandflag" + f.BoolP(name, "n", true, "always true") + usageMsg := fmt.Sprintf("use --%s instead", name) + f.MarkShorthandDeprecated(name, usageMsg) + + args := []string{"-n"} + out, err := parseReturnStderr(t, f, args) + if err != nil { + t.Fatal("expected no error; got ", err) + } + + if !strings.Contains(out, usageMsg) { + t.Errorf("usageMsg not printed when using a deprecated flag!") + } +} + +func TestDeprecatedFlagUsageNormalized(t *testing.T) { + f := NewFlagSet("bob", ContinueOnError) + f.Bool("bad-double_flag", true, "always true") + f.SetNormalizeFunc(wordSepNormalizeFunc) + usageMsg := "use --good-flag instead" + f.MarkDeprecated("bad_double-flag", usageMsg) + + args := []string{"--bad_double_flag"} + out, err := parseReturnStderr(t, f, args) + if err != nil { + t.Fatal("expected no error; got ", err) + } + + if !strings.Contains(out, usageMsg) { + t.Errorf("usageMsg not printed when using a deprecated flag!") + } +} + +// Name normalization function should be called only once on flag addition +func TestMultipleNormalizeFlagNameInvocations(t *testing.T) { + normalizeFlagNameInvocations = 0 + + f := NewFlagSet("normalized", ContinueOnError) + f.SetNormalizeFunc(wordSepNormalizeFunc) + f.Bool("with_under_flag", false, "bool value") + + if normalizeFlagNameInvocations != 1 { + t.Fatal("Expected normalizeFlagNameInvocations to be 1; got ", normalizeFlagNameInvocations) + } +} + +// +func TestHiddenFlagInUsage(t *testing.T) { + f := NewFlagSet("bob", ContinueOnError) + f.Bool("secretFlag", true, "shhh") + f.MarkHidden("secretFlag") + + out := new(bytes.Buffer) + f.SetOutput(out) + f.PrintDefaults() + + if strings.Contains(out.String(), "secretFlag") { + t.Errorf("found hidden flag in usage!") + } +} + +// +func TestHiddenFlagUsage(t *testing.T) { + f := NewFlagSet("bob", ContinueOnError) + f.Bool("secretFlag", true, "shhh") + f.MarkHidden("secretFlag") + + args := []string{"--secretFlag"} + out, err := parseReturnStderr(t, f, args) + if err != nil { + t.Fatal("expected no error; got ", err) + } + + if strings.Contains(out, "shhh") { + t.Errorf("usage message printed when using a hidden flag!") + } +} + +const defaultOutput = ` --A for bootstrapping, allow 'any' type + --Alongflagname disable bounds checking + -C, --CCC a boolean defaulting to true (default true) + --D path set relative path for local imports + --F number a non-zero number (default 2.7) + --G float a float that defaults to zero + --N int a non-zero int (default 27) + --ND1 string[="bar"] a string with NoOptDefVal (default "foo") + --ND2 num[=4321] a num with NoOptDefVal (default 1234) + --Z int an int that defaults to zero + --maxT timeout set timeout for dial +` + +func TestPrintDefaults(t *testing.T) { + fs := NewFlagSet("print defaults test", ContinueOnError) + var buf bytes.Buffer + fs.SetOutput(&buf) + fs.Bool("A", false, "for bootstrapping, allow 'any' type") + fs.Bool("Alongflagname", false, "disable bounds checking") + fs.BoolP("CCC", "C", true, "a boolean defaulting to true") + fs.String("D", "", "set relative `path` for local imports") + fs.Float64("F", 2.7, "a non-zero `number`") + fs.Float64("G", 0, "a float that defaults to zero") + fs.Int("N", 27, "a non-zero int") + fs.Int("Z", 0, "an int that defaults to zero") + fs.Duration("maxT", 0, "set `timeout` for dial") + fs.String("ND1", "foo", "a string with NoOptDefVal") + fs.Lookup("ND1").NoOptDefVal = "bar" + fs.Int("ND2", 1234, "a `num` with NoOptDefVal") + fs.Lookup("ND2").NoOptDefVal = "4321" + fs.PrintDefaults() + got := buf.String() + if got != defaultOutput { + fmt.Println("\n" + got) + fmt.Println("\n" + defaultOutput) + t.Errorf("got %q want %q\n", got, defaultOutput) + } +} diff --git a/vendor/github.com/spf13/pflag/float32.go b/vendor/github.com/spf13/pflag/float32.go new file mode 100644 index 000000000..7683fae1b --- /dev/null +++ b/vendor/github.com/spf13/pflag/float32.go @@ -0,0 +1,91 @@ +package pflag + +import ( + "fmt" + "strconv" +) + +// -- float32 Value +type float32Value float32 + +func newFloat32Value(val float32, p *float32) *float32Value { + *p = val + return (*float32Value)(p) +} + +func (f *float32Value) Set(s string) error { + v, err := strconv.ParseFloat(s, 32) + *f = float32Value(v) + return err +} + +func (f *float32Value) Type() string { + return "float32" +} + +func (f *float32Value) String() string { return fmt.Sprintf("%v", *f) } + +func float32Conv(sval string) (interface{}, error) { + v, err := strconv.ParseFloat(sval, 32) + if err != nil { + return 0, err + } + return float32(v), nil +} + +// GetFloat32 return the float32 value of a flag with the given name +func (f *FlagSet) GetFloat32(name string) (float32, error) { + val, err := f.getFlagType(name, "float32", float32Conv) + if err != nil { + return 0, err + } + return val.(float32), nil +} + +// Float32Var defines a float32 flag with specified name, default value, and usage string. +// The argument p points to a float32 variable in which to store the value of the flag. +func (f *FlagSet) Float32Var(p *float32, name string, value float32, usage string) { + f.VarP(newFloat32Value(value, p), name, "", usage) +} + +// Float32VarP is like Float32Var, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) Float32VarP(p *float32, name, shorthand string, value float32, usage string) { + f.VarP(newFloat32Value(value, p), name, shorthand, usage) +} + +// Float32Var defines a float32 flag with specified name, default value, and usage string. +// The argument p points to a float32 variable in which to store the value of the flag. +func Float32Var(p *float32, name string, value float32, usage string) { + CommandLine.VarP(newFloat32Value(value, p), name, "", usage) +} + +// Float32VarP is like Float32Var, but accepts a shorthand letter that can be used after a single dash. +func Float32VarP(p *float32, name, shorthand string, value float32, usage string) { + CommandLine.VarP(newFloat32Value(value, p), name, shorthand, usage) +} + +// Float32 defines a float32 flag with specified name, default value, and usage string. +// The return value is the address of a float32 variable that stores the value of the flag. +func (f *FlagSet) Float32(name string, value float32, usage string) *float32 { + p := new(float32) + f.Float32VarP(p, name, "", value, usage) + return p +} + +// Float32P is like Float32, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) Float32P(name, shorthand string, value float32, usage string) *float32 { + p := new(float32) + f.Float32VarP(p, name, shorthand, value, usage) + return p +} + +// Float32 defines a float32 flag with specified name, default value, and usage string. +// The return value is the address of a float32 variable that stores the value of the flag. +func Float32(name string, value float32, usage string) *float32 { + return CommandLine.Float32P(name, "", value, usage) +} + +// Float32P is like Float32, but accepts a shorthand letter that can be used after a single dash. +func Float32P(name, shorthand string, value float32, usage string) *float32 { + return CommandLine.Float32P(name, shorthand, value, usage) +} diff --git a/vendor/github.com/spf13/pflag/float64.go b/vendor/github.com/spf13/pflag/float64.go new file mode 100644 index 000000000..50fbf8cc1 --- /dev/null +++ b/vendor/github.com/spf13/pflag/float64.go @@ -0,0 +1,87 @@ +package pflag + +import ( + "fmt" + "strconv" +) + +// -- float64 Value +type float64Value float64 + +func newFloat64Value(val float64, p *float64) *float64Value { + *p = val + return (*float64Value)(p) +} + +func (f *float64Value) Set(s string) error { + v, err := strconv.ParseFloat(s, 64) + *f = float64Value(v) + return err +} + +func (f *float64Value) Type() string { + return "float64" +} + +func (f *float64Value) String() string { return fmt.Sprintf("%v", *f) } + +func float64Conv(sval string) (interface{}, error) { + return strconv.ParseFloat(sval, 64) +} + +// GetFloat64 return the float64 value of a flag with the given name +func (f *FlagSet) GetFloat64(name string) (float64, error) { + val, err := f.getFlagType(name, "float64", float64Conv) + if err != nil { + return 0, err + } + return val.(float64), nil +} + +// Float64Var defines a float64 flag with specified name, default value, and usage string. +// The argument p points to a float64 variable in which to store the value of the flag. +func (f *FlagSet) Float64Var(p *float64, name string, value float64, usage string) { + f.VarP(newFloat64Value(value, p), name, "", usage) +} + +// Float64VarP is like Float64Var, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) Float64VarP(p *float64, name, shorthand string, value float64, usage string) { + f.VarP(newFloat64Value(value, p), name, shorthand, usage) +} + +// Float64Var defines a float64 flag with specified name, default value, and usage string. +// The argument p points to a float64 variable in which to store the value of the flag. +func Float64Var(p *float64, name string, value float64, usage string) { + CommandLine.VarP(newFloat64Value(value, p), name, "", usage) +} + +// Float64VarP is like Float64Var, but accepts a shorthand letter that can be used after a single dash. +func Float64VarP(p *float64, name, shorthand string, value float64, usage string) { + CommandLine.VarP(newFloat64Value(value, p), name, shorthand, usage) +} + +// Float64 defines a float64 flag with specified name, default value, and usage string. +// The return value is the address of a float64 variable that stores the value of the flag. +func (f *FlagSet) Float64(name string, value float64, usage string) *float64 { + p := new(float64) + f.Float64VarP(p, name, "", value, usage) + return p +} + +// Float64P is like Float64, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) Float64P(name, shorthand string, value float64, usage string) *float64 { + p := new(float64) + f.Float64VarP(p, name, shorthand, value, usage) + return p +} + +// Float64 defines a float64 flag with specified name, default value, and usage string. +// The return value is the address of a float64 variable that stores the value of the flag. +func Float64(name string, value float64, usage string) *float64 { + return CommandLine.Float64P(name, "", value, usage) +} + +// Float64P is like Float64, but accepts a shorthand letter that can be used after a single dash. +func Float64P(name, shorthand string, value float64, usage string) *float64 { + return CommandLine.Float64P(name, shorthand, value, usage) +} diff --git a/vendor/github.com/spf13/pflag/golangflag.go b/vendor/github.com/spf13/pflag/golangflag.go new file mode 100644 index 000000000..b056147fd --- /dev/null +++ b/vendor/github.com/spf13/pflag/golangflag.go @@ -0,0 +1,104 @@ +// Copyright 2009 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package pflag + +import ( + goflag "flag" + "fmt" + "reflect" + "strings" +) + +var _ = fmt.Print + +// flagValueWrapper implements pflag.Value around a flag.Value. The main +// difference here is the addition of the Type method that returns a string +// name of the type. As this is generally unknown, we approximate that with +// reflection. +type flagValueWrapper struct { + inner goflag.Value + flagType string +} + +// We are just copying the boolFlag interface out of goflag as that is what +// they use to decide if a flag should get "true" when no arg is given. +type goBoolFlag interface { + goflag.Value + IsBoolFlag() bool +} + +func wrapFlagValue(v goflag.Value) Value { + // If the flag.Value happens to also be a pflag.Value, just use it directly. + if pv, ok := v.(Value); ok { + return pv + } + + pv := &flagValueWrapper{ + inner: v, + } + + t := reflect.TypeOf(v) + if t.Kind() == reflect.Interface || t.Kind() == reflect.Ptr { + t = t.Elem() + } + + pv.flagType = strings.TrimSuffix(t.Name(), "Value") + return pv +} + +func (v *flagValueWrapper) String() string { + return v.inner.String() +} + +func (v *flagValueWrapper) Set(s string) error { + return v.inner.Set(s) +} + +func (v *flagValueWrapper) Type() string { + return v.flagType +} + +// PFlagFromGoFlag will return a *pflag.Flag given a *flag.Flag +// If the *flag.Flag.Name was a single character (ex: `v`) it will be accessiblei +// with both `-v` and `--v` in flags. If the golang flag was more than a single +// character (ex: `verbose`) it will only be accessible via `--verbose` +func PFlagFromGoFlag(goflag *goflag.Flag) *Flag { + // Remember the default value as a string; it won't change. + flag := &Flag{ + Name: goflag.Name, + Usage: goflag.Usage, + Value: wrapFlagValue(goflag.Value), + // Looks like golang flags don't set DefValue correctly :-( + //DefValue: goflag.DefValue, + DefValue: goflag.Value.String(), + } + // Ex: if the golang flag was -v, allow both -v and --v to work + if len(flag.Name) == 1 { + flag.Shorthand = flag.Name + } + if fv, ok := goflag.Value.(goBoolFlag); ok && fv.IsBoolFlag() { + flag.NoOptDefVal = "true" + } + return flag +} + +// AddGoFlag will add the given *flag.Flag to the pflag.FlagSet +func (f *FlagSet) AddGoFlag(goflag *goflag.Flag) { + if f.Lookup(goflag.Name) != nil { + return + } + newflag := PFlagFromGoFlag(goflag) + f.AddFlag(newflag) +} + +// AddGoFlagSet will add the given *flag.FlagSet to the pflag.FlagSet +func (f *FlagSet) AddGoFlagSet(newSet *goflag.FlagSet) { + if newSet == nil { + return + } + newSet.VisitAll(func(goflag *goflag.Flag) { + f.AddGoFlag(goflag) + }) +} diff --git a/vendor/github.com/spf13/pflag/golangflag_test.go b/vendor/github.com/spf13/pflag/golangflag_test.go new file mode 100644 index 000000000..77e2d7d80 --- /dev/null +++ b/vendor/github.com/spf13/pflag/golangflag_test.go @@ -0,0 +1,39 @@ +// Copyright 2009 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package pflag + +import ( + goflag "flag" + "testing" +) + +func TestGoflags(t *testing.T) { + goflag.String("stringFlag", "stringFlag", "stringFlag") + goflag.Bool("boolFlag", false, "boolFlag") + + f := NewFlagSet("test", ContinueOnError) + + f.AddGoFlagSet(goflag.CommandLine) + err := f.Parse([]string{"--stringFlag=bob", "--boolFlag"}) + if err != nil { + t.Fatal("expected no error; get", err) + } + + getString, err := f.GetString("stringFlag") + if err != nil { + t.Fatal("expected no error; get", err) + } + if getString != "bob" { + t.Fatalf("expected getString=bob but got getString=%s", getString) + } + + getBool, err := f.GetBool("boolFlag") + if err != nil { + t.Fatal("expected no error; get", err) + } + if getBool != true { + t.Fatalf("expected getBool=true but got getBool=%v", getBool) + } +} diff --git a/vendor/github.com/spf13/pflag/int.go b/vendor/github.com/spf13/pflag/int.go new file mode 100644 index 000000000..b6560368a --- /dev/null +++ b/vendor/github.com/spf13/pflag/int.go @@ -0,0 +1,87 @@ +package pflag + +import ( + "fmt" + "strconv" +) + +// -- int Value +type intValue int + +func newIntValue(val int, p *int) *intValue { + *p = val + return (*intValue)(p) +} + +func (i *intValue) Set(s string) error { + v, err := strconv.ParseInt(s, 0, 64) + *i = intValue(v) + return err +} + +func (i *intValue) Type() string { + return "int" +} + +func (i *intValue) String() string { return fmt.Sprintf("%v", *i) } + +func intConv(sval string) (interface{}, error) { + return strconv.Atoi(sval) +} + +// GetInt return the int value of a flag with the given name +func (f *FlagSet) GetInt(name string) (int, error) { + val, err := f.getFlagType(name, "int", intConv) + if err != nil { + return 0, err + } + return val.(int), nil +} + +// IntVar defines an int flag with specified name, default value, and usage string. +// The argument p points to an int variable in which to store the value of the flag. +func (f *FlagSet) IntVar(p *int, name string, value int, usage string) { + f.VarP(newIntValue(value, p), name, "", usage) +} + +// IntVarP is like IntVar, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) IntVarP(p *int, name, shorthand string, value int, usage string) { + f.VarP(newIntValue(value, p), name, shorthand, usage) +} + +// IntVar defines an int flag with specified name, default value, and usage string. +// The argument p points to an int variable in which to store the value of the flag. +func IntVar(p *int, name string, value int, usage string) { + CommandLine.VarP(newIntValue(value, p), name, "", usage) +} + +// IntVarP is like IntVar, but accepts a shorthand letter that can be used after a single dash. +func IntVarP(p *int, name, shorthand string, value int, usage string) { + CommandLine.VarP(newIntValue(value, p), name, shorthand, usage) +} + +// Int defines an int flag with specified name, default value, and usage string. +// The return value is the address of an int variable that stores the value of the flag. +func (f *FlagSet) Int(name string, value int, usage string) *int { + p := new(int) + f.IntVarP(p, name, "", value, usage) + return p +} + +// IntP is like Int, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) IntP(name, shorthand string, value int, usage string) *int { + p := new(int) + f.IntVarP(p, name, shorthand, value, usage) + return p +} + +// Int defines an int flag with specified name, default value, and usage string. +// The return value is the address of an int variable that stores the value of the flag. +func Int(name string, value int, usage string) *int { + return CommandLine.IntP(name, "", value, usage) +} + +// IntP is like Int, but accepts a shorthand letter that can be used after a single dash. +func IntP(name, shorthand string, value int, usage string) *int { + return CommandLine.IntP(name, shorthand, value, usage) +} diff --git a/vendor/github.com/spf13/pflag/int32.go b/vendor/github.com/spf13/pflag/int32.go new file mode 100644 index 000000000..41659a9af --- /dev/null +++ b/vendor/github.com/spf13/pflag/int32.go @@ -0,0 +1,91 @@ +package pflag + +import ( + "fmt" + "strconv" +) + +// -- int32 Value +type int32Value int32 + +func newInt32Value(val int32, p *int32) *int32Value { + *p = val + return (*int32Value)(p) +} + +func (i *int32Value) Set(s string) error { + v, err := strconv.ParseInt(s, 0, 32) + *i = int32Value(v) + return err +} + +func (i *int32Value) Type() string { + return "int32" +} + +func (i *int32Value) String() string { return fmt.Sprintf("%v", *i) } + +func int32Conv(sval string) (interface{}, error) { + v, err := strconv.ParseInt(sval, 0, 32) + if err != nil { + return 0, err + } + return int32(v), nil +} + +// GetInt32 return the int32 value of a flag with the given name +func (f *FlagSet) GetInt32(name string) (int32, error) { + val, err := f.getFlagType(name, "int32", int32Conv) + if err != nil { + return 0, err + } + return val.(int32), nil +} + +// Int32Var defines an int32 flag with specified name, default value, and usage string. +// The argument p points to an int32 variable in which to store the value of the flag. +func (f *FlagSet) Int32Var(p *int32, name string, value int32, usage string) { + f.VarP(newInt32Value(value, p), name, "", usage) +} + +// Int32VarP is like Int32Var, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) Int32VarP(p *int32, name, shorthand string, value int32, usage string) { + f.VarP(newInt32Value(value, p), name, shorthand, usage) +} + +// Int32Var defines an int32 flag with specified name, default value, and usage string. +// The argument p points to an int32 variable in which to store the value of the flag. +func Int32Var(p *int32, name string, value int32, usage string) { + CommandLine.VarP(newInt32Value(value, p), name, "", usage) +} + +// Int32VarP is like Int32Var, but accepts a shorthand letter that can be used after a single dash. +func Int32VarP(p *int32, name, shorthand string, value int32, usage string) { + CommandLine.VarP(newInt32Value(value, p), name, shorthand, usage) +} + +// Int32 defines an int32 flag with specified name, default value, and usage string. +// The return value is the address of an int32 variable that stores the value of the flag. +func (f *FlagSet) Int32(name string, value int32, usage string) *int32 { + p := new(int32) + f.Int32VarP(p, name, "", value, usage) + return p +} + +// Int32P is like Int32, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) Int32P(name, shorthand string, value int32, usage string) *int32 { + p := new(int32) + f.Int32VarP(p, name, shorthand, value, usage) + return p +} + +// Int32 defines an int32 flag with specified name, default value, and usage string. +// The return value is the address of an int32 variable that stores the value of the flag. +func Int32(name string, value int32, usage string) *int32 { + return CommandLine.Int32P(name, "", value, usage) +} + +// Int32P is like Int32, but accepts a shorthand letter that can be used after a single dash. +func Int32P(name, shorthand string, value int32, usage string) *int32 { + return CommandLine.Int32P(name, shorthand, value, usage) +} diff --git a/vendor/github.com/spf13/pflag/int64.go b/vendor/github.com/spf13/pflag/int64.go new file mode 100644 index 000000000..6e67e380f --- /dev/null +++ b/vendor/github.com/spf13/pflag/int64.go @@ -0,0 +1,87 @@ +package pflag + +import ( + "fmt" + "strconv" +) + +// -- int64 Value +type int64Value int64 + +func newInt64Value(val int64, p *int64) *int64Value { + *p = val + return (*int64Value)(p) +} + +func (i *int64Value) Set(s string) error { + v, err := strconv.ParseInt(s, 0, 64) + *i = int64Value(v) + return err +} + +func (i *int64Value) Type() string { + return "int64" +} + +func (i *int64Value) String() string { return fmt.Sprintf("%v", *i) } + +func int64Conv(sval string) (interface{}, error) { + return strconv.ParseInt(sval, 0, 64) +} + +// GetInt64 return the int64 value of a flag with the given name +func (f *FlagSet) GetInt64(name string) (int64, error) { + val, err := f.getFlagType(name, "int64", int64Conv) + if err != nil { + return 0, err + } + return val.(int64), nil +} + +// Int64Var defines an int64 flag with specified name, default value, and usage string. +// The argument p points to an int64 variable in which to store the value of the flag. +func (f *FlagSet) Int64Var(p *int64, name string, value int64, usage string) { + f.VarP(newInt64Value(value, p), name, "", usage) +} + +// Int64VarP is like Int64Var, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) Int64VarP(p *int64, name, shorthand string, value int64, usage string) { + f.VarP(newInt64Value(value, p), name, shorthand, usage) +} + +// Int64Var defines an int64 flag with specified name, default value, and usage string. +// The argument p points to an int64 variable in which to store the value of the flag. +func Int64Var(p *int64, name string, value int64, usage string) { + CommandLine.VarP(newInt64Value(value, p), name, "", usage) +} + +// Int64VarP is like Int64Var, but accepts a shorthand letter that can be used after a single dash. +func Int64VarP(p *int64, name, shorthand string, value int64, usage string) { + CommandLine.VarP(newInt64Value(value, p), name, shorthand, usage) +} + +// Int64 defines an int64 flag with specified name, default value, and usage string. +// The return value is the address of an int64 variable that stores the value of the flag. +func (f *FlagSet) Int64(name string, value int64, usage string) *int64 { + p := new(int64) + f.Int64VarP(p, name, "", value, usage) + return p +} + +// Int64P is like Int64, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) Int64P(name, shorthand string, value int64, usage string) *int64 { + p := new(int64) + f.Int64VarP(p, name, shorthand, value, usage) + return p +} + +// Int64 defines an int64 flag with specified name, default value, and usage string. +// The return value is the address of an int64 variable that stores the value of the flag. +func Int64(name string, value int64, usage string) *int64 { + return CommandLine.Int64P(name, "", value, usage) +} + +// Int64P is like Int64, but accepts a shorthand letter that can be used after a single dash. +func Int64P(name, shorthand string, value int64, usage string) *int64 { + return CommandLine.Int64P(name, shorthand, value, usage) +} diff --git a/vendor/github.com/spf13/pflag/int8.go b/vendor/github.com/spf13/pflag/int8.go new file mode 100644 index 000000000..400db21f5 --- /dev/null +++ b/vendor/github.com/spf13/pflag/int8.go @@ -0,0 +1,91 @@ +package pflag + +import ( + "fmt" + "strconv" +) + +// -- int8 Value +type int8Value int8 + +func newInt8Value(val int8, p *int8) *int8Value { + *p = val + return (*int8Value)(p) +} + +func (i *int8Value) Set(s string) error { + v, err := strconv.ParseInt(s, 0, 8) + *i = int8Value(v) + return err +} + +func (i *int8Value) Type() string { + return "int8" +} + +func (i *int8Value) String() string { return fmt.Sprintf("%v", *i) } + +func int8Conv(sval string) (interface{}, error) { + v, err := strconv.ParseInt(sval, 0, 8) + if err != nil { + return 0, err + } + return int8(v), nil +} + +// GetInt8 return the int8 value of a flag with the given name +func (f *FlagSet) GetInt8(name string) (int8, error) { + val, err := f.getFlagType(name, "int8", int8Conv) + if err != nil { + return 0, err + } + return val.(int8), nil +} + +// Int8Var defines an int8 flag with specified name, default value, and usage string. +// The argument p points to an int8 variable in which to store the value of the flag. +func (f *FlagSet) Int8Var(p *int8, name string, value int8, usage string) { + f.VarP(newInt8Value(value, p), name, "", usage) +} + +// Int8VarP is like Int8Var, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) Int8VarP(p *int8, name, shorthand string, value int8, usage string) { + f.VarP(newInt8Value(value, p), name, shorthand, usage) +} + +// Int8Var defines an int8 flag with specified name, default value, and usage string. +// The argument p points to an int8 variable in which to store the value of the flag. +func Int8Var(p *int8, name string, value int8, usage string) { + CommandLine.VarP(newInt8Value(value, p), name, "", usage) +} + +// Int8VarP is like Int8Var, but accepts a shorthand letter that can be used after a single dash. +func Int8VarP(p *int8, name, shorthand string, value int8, usage string) { + CommandLine.VarP(newInt8Value(value, p), name, shorthand, usage) +} + +// Int8 defines an int8 flag with specified name, default value, and usage string. +// The return value is the address of an int8 variable that stores the value of the flag. +func (f *FlagSet) Int8(name string, value int8, usage string) *int8 { + p := new(int8) + f.Int8VarP(p, name, "", value, usage) + return p +} + +// Int8P is like Int8, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) Int8P(name, shorthand string, value int8, usage string) *int8 { + p := new(int8) + f.Int8VarP(p, name, shorthand, value, usage) + return p +} + +// Int8 defines an int8 flag with specified name, default value, and usage string. +// The return value is the address of an int8 variable that stores the value of the flag. +func Int8(name string, value int8, usage string) *int8 { + return CommandLine.Int8P(name, "", value, usage) +} + +// Int8P is like Int8, but accepts a shorthand letter that can be used after a single dash. +func Int8P(name, shorthand string, value int8, usage string) *int8 { + return CommandLine.Int8P(name, shorthand, value, usage) +} diff --git a/vendor/github.com/spf13/pflag/int_slice.go b/vendor/github.com/spf13/pflag/int_slice.go new file mode 100644 index 000000000..1e7c9edde --- /dev/null +++ b/vendor/github.com/spf13/pflag/int_slice.go @@ -0,0 +1,128 @@ +package pflag + +import ( + "fmt" + "strconv" + "strings" +) + +// -- intSlice Value +type intSliceValue struct { + value *[]int + changed bool +} + +func newIntSliceValue(val []int, p *[]int) *intSliceValue { + isv := new(intSliceValue) + isv.value = p + *isv.value = val + return isv +} + +func (s *intSliceValue) Set(val string) error { + ss := strings.Split(val, ",") + out := make([]int, len(ss)) + for i, d := range ss { + var err error + out[i], err = strconv.Atoi(d) + if err != nil { + return err + } + + } + if !s.changed { + *s.value = out + } else { + *s.value = append(*s.value, out...) + } + s.changed = true + return nil +} + +func (s *intSliceValue) Type() string { + return "intSlice" +} + +func (s *intSliceValue) String() string { + out := make([]string, len(*s.value)) + for i, d := range *s.value { + out[i] = fmt.Sprintf("%d", d) + } + return "[" + strings.Join(out, ",") + "]" +} + +func intSliceConv(val string) (interface{}, error) { + val = strings.Trim(val, "[]") + // Empty string would cause a slice with one (empty) entry + if len(val) == 0 { + return []int{}, nil + } + ss := strings.Split(val, ",") + out := make([]int, len(ss)) + for i, d := range ss { + var err error + out[i], err = strconv.Atoi(d) + if err != nil { + return nil, err + } + + } + return out, nil +} + +// GetIntSlice return the []int value of a flag with the given name +func (f *FlagSet) GetIntSlice(name string) ([]int, error) { + val, err := f.getFlagType(name, "intSlice", intSliceConv) + if err != nil { + return []int{}, err + } + return val.([]int), nil +} + +// IntSliceVar defines a intSlice flag with specified name, default value, and usage string. +// The argument p points to a []int variable in which to store the value of the flag. +func (f *FlagSet) IntSliceVar(p *[]int, name string, value []int, usage string) { + f.VarP(newIntSliceValue(value, p), name, "", usage) +} + +// IntSliceVarP is like IntSliceVar, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) IntSliceVarP(p *[]int, name, shorthand string, value []int, usage string) { + f.VarP(newIntSliceValue(value, p), name, shorthand, usage) +} + +// IntSliceVar defines a int[] flag with specified name, default value, and usage string. +// The argument p points to a int[] variable in which to store the value of the flag. +func IntSliceVar(p *[]int, name string, value []int, usage string) { + CommandLine.VarP(newIntSliceValue(value, p), name, "", usage) +} + +// IntSliceVarP is like IntSliceVar, but accepts a shorthand letter that can be used after a single dash. +func IntSliceVarP(p *[]int, name, shorthand string, value []int, usage string) { + CommandLine.VarP(newIntSliceValue(value, p), name, shorthand, usage) +} + +// IntSlice defines a []int flag with specified name, default value, and usage string. +// The return value is the address of a []int variable that stores the value of the flag. +func (f *FlagSet) IntSlice(name string, value []int, usage string) *[]int { + p := []int{} + f.IntSliceVarP(&p, name, "", value, usage) + return &p +} + +// IntSliceP is like IntSlice, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) IntSliceP(name, shorthand string, value []int, usage string) *[]int { + p := []int{} + f.IntSliceVarP(&p, name, shorthand, value, usage) + return &p +} + +// IntSlice defines a []int flag with specified name, default value, and usage string. +// The return value is the address of a []int variable that stores the value of the flag. +func IntSlice(name string, value []int, usage string) *[]int { + return CommandLine.IntSliceP(name, "", value, usage) +} + +// IntSliceP is like IntSlice, but accepts a shorthand letter that can be used after a single dash. +func IntSliceP(name, shorthand string, value []int, usage string) *[]int { + return CommandLine.IntSliceP(name, shorthand, value, usage) +} diff --git a/vendor/github.com/spf13/pflag/int_slice_test.go b/vendor/github.com/spf13/pflag/int_slice_test.go new file mode 100644 index 000000000..5f2eee66a --- /dev/null +++ b/vendor/github.com/spf13/pflag/int_slice_test.go @@ -0,0 +1,162 @@ +// Copyright 2009 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package pflag + +import ( + "fmt" + "strconv" + "strings" + "testing" +) + +func setUpISFlagSet(isp *[]int) *FlagSet { + f := NewFlagSet("test", ContinueOnError) + f.IntSliceVar(isp, "is", []int{}, "Command separated list!") + return f +} + +func setUpISFlagSetWithDefault(isp *[]int) *FlagSet { + f := NewFlagSet("test", ContinueOnError) + f.IntSliceVar(isp, "is", []int{0, 1}, "Command separated list!") + return f +} + +func TestEmptyIS(t *testing.T) { + var is []int + f := setUpISFlagSet(&is) + err := f.Parse([]string{}) + if err != nil { + t.Fatal("expected no error; got", err) + } + + getIS, err := f.GetIntSlice("is") + if err != nil { + t.Fatal("got an error from GetIntSlice():", err) + } + if len(getIS) != 0 { + t.Fatalf("got is %v with len=%d but expected length=0", getIS, len(getIS)) + } +} + +func TestIS(t *testing.T) { + var is []int + f := setUpISFlagSet(&is) + + vals := []string{"1", "2", "4", "3"} + arg := fmt.Sprintf("--is=%s", strings.Join(vals, ",")) + err := f.Parse([]string{arg}) + if err != nil { + t.Fatal("expected no error; got", err) + } + for i, v := range is { + d, err := strconv.Atoi(vals[i]) + if err != nil { + t.Fatalf("got error: %v", err) + } + if d != v { + t.Fatalf("expected is[%d] to be %s but got: %d", i, vals[i], v) + } + } + getIS, err := f.GetIntSlice("is") + for i, v := range getIS { + d, err := strconv.Atoi(vals[i]) + if err != nil { + t.Fatalf("got error: %v", err) + } + if d != v { + t.Fatalf("expected is[%d] to be %s but got: %d from GetIntSlice", i, vals[i], v) + } + } +} + +func TestISDefault(t *testing.T) { + var is []int + f := setUpISFlagSetWithDefault(&is) + + vals := []string{"0", "1"} + + err := f.Parse([]string{}) + if err != nil { + t.Fatal("expected no error; got", err) + } + for i, v := range is { + d, err := strconv.Atoi(vals[i]) + if err != nil { + t.Fatalf("got error: %v", err) + } + if d != v { + t.Fatalf("expected is[%d] to be %d but got: %d", i, d, v) + } + } + + getIS, err := f.GetIntSlice("is") + if err != nil { + t.Fatal("got an error from GetIntSlice():", err) + } + for i, v := range getIS { + d, err := strconv.Atoi(vals[i]) + if err != nil { + t.Fatal("got an error from GetIntSlice():", err) + } + if d != v { + t.Fatalf("expected is[%d] to be %d from GetIntSlice but got: %d", i, d, v) + } + } +} + +func TestISWithDefault(t *testing.T) { + var is []int + f := setUpISFlagSetWithDefault(&is) + + vals := []string{"1", "2"} + arg := fmt.Sprintf("--is=%s", strings.Join(vals, ",")) + err := f.Parse([]string{arg}) + if err != nil { + t.Fatal("expected no error; got", err) + } + for i, v := range is { + d, err := strconv.Atoi(vals[i]) + if err != nil { + t.Fatalf("got error: %v", err) + } + if d != v { + t.Fatalf("expected is[%d] to be %d but got: %d", i, d, v) + } + } + + getIS, err := f.GetIntSlice("is") + if err != nil { + t.Fatal("got an error from GetIntSlice():", err) + } + for i, v := range getIS { + d, err := strconv.Atoi(vals[i]) + if err != nil { + t.Fatalf("got error: %v", err) + } + if d != v { + t.Fatalf("expected is[%d] to be %d from GetIntSlice but got: %d", i, d, v) + } + } +} + +func TestISCalledTwice(t *testing.T) { + var is []int + f := setUpISFlagSet(&is) + + in := []string{"1,2", "3"} + expected := []int{1, 2, 3} + argfmt := "--is=%s" + arg1 := fmt.Sprintf(argfmt, in[0]) + arg2 := fmt.Sprintf(argfmt, in[1]) + err := f.Parse([]string{arg1, arg2}) + if err != nil { + t.Fatal("expected no error; got", err) + } + for i, v := range is { + if expected[i] != v { + t.Fatalf("expected is[%d] to be %d but got: %d", i, expected[i], v) + } + } +} diff --git a/vendor/github.com/spf13/pflag/ip.go b/vendor/github.com/spf13/pflag/ip.go new file mode 100644 index 000000000..88a17430a --- /dev/null +++ b/vendor/github.com/spf13/pflag/ip.go @@ -0,0 +1,96 @@ +package pflag + +import ( + "fmt" + "net" + "strings" +) + +var _ = strings.TrimSpace + +// -- net.IP value +type ipValue net.IP + +func newIPValue(val net.IP, p *net.IP) *ipValue { + *p = val + return (*ipValue)(p) +} + +func (i *ipValue) String() string { return net.IP(*i).String() } +func (i *ipValue) Set(s string) error { + ip := net.ParseIP(strings.TrimSpace(s)) + if ip == nil { + return fmt.Errorf("failed to parse IP: %q", s) + } + *i = ipValue(ip) + return nil +} + +func (i *ipValue) Type() string { + return "ip" +} + +func ipConv(sval string) (interface{}, error) { + ip := net.ParseIP(sval) + if ip != nil { + return ip, nil + } + return nil, fmt.Errorf("invalid string being converted to IP address: %s", sval) +} + +// GetIP return the net.IP value of a flag with the given name +func (f *FlagSet) GetIP(name string) (net.IP, error) { + val, err := f.getFlagType(name, "ip", ipConv) + if err != nil { + return nil, err + } + return val.(net.IP), nil +} + +// IPVar defines an net.IP flag with specified name, default value, and usage string. +// The argument p points to an net.IP variable in which to store the value of the flag. +func (f *FlagSet) IPVar(p *net.IP, name string, value net.IP, usage string) { + f.VarP(newIPValue(value, p), name, "", usage) +} + +// IPVarP is like IPVar, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) IPVarP(p *net.IP, name, shorthand string, value net.IP, usage string) { + f.VarP(newIPValue(value, p), name, shorthand, usage) +} + +// IPVar defines an net.IP flag with specified name, default value, and usage string. +// The argument p points to an net.IP variable in which to store the value of the flag. +func IPVar(p *net.IP, name string, value net.IP, usage string) { + CommandLine.VarP(newIPValue(value, p), name, "", usage) +} + +// IPVarP is like IPVar, but accepts a shorthand letter that can be used after a single dash. +func IPVarP(p *net.IP, name, shorthand string, value net.IP, usage string) { + CommandLine.VarP(newIPValue(value, p), name, shorthand, usage) +} + +// IP defines an net.IP flag with specified name, default value, and usage string. +// The return value is the address of an net.IP variable that stores the value of the flag. +func (f *FlagSet) IP(name string, value net.IP, usage string) *net.IP { + p := new(net.IP) + f.IPVarP(p, name, "", value, usage) + return p +} + +// IPP is like IP, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) IPP(name, shorthand string, value net.IP, usage string) *net.IP { + p := new(net.IP) + f.IPVarP(p, name, shorthand, value, usage) + return p +} + +// IP defines an net.IP flag with specified name, default value, and usage string. +// The return value is the address of an net.IP variable that stores the value of the flag. +func IP(name string, value net.IP, usage string) *net.IP { + return CommandLine.IPP(name, "", value, usage) +} + +// IPP is like IP, but accepts a shorthand letter that can be used after a single dash. +func IPP(name, shorthand string, value net.IP, usage string) *net.IP { + return CommandLine.IPP(name, shorthand, value, usage) +} diff --git a/vendor/github.com/spf13/pflag/ip_test.go b/vendor/github.com/spf13/pflag/ip_test.go new file mode 100644 index 000000000..1fec50e42 --- /dev/null +++ b/vendor/github.com/spf13/pflag/ip_test.go @@ -0,0 +1,63 @@ +package pflag + +import ( + "fmt" + "net" + "os" + "testing" +) + +func setUpIP(ip *net.IP) *FlagSet { + f := NewFlagSet("test", ContinueOnError) + f.IPVar(ip, "address", net.ParseIP("0.0.0.0"), "IP Address") + return f +} + +func TestIP(t *testing.T) { + testCases := []struct { + input string + success bool + expected string + }{ + {"0.0.0.0", true, "0.0.0.0"}, + {" 0.0.0.0 ", true, "0.0.0.0"}, + {"1.2.3.4", true, "1.2.3.4"}, + {"127.0.0.1", true, "127.0.0.1"}, + {"255.255.255.255", true, "255.255.255.255"}, + {"", false, ""}, + {"0", false, ""}, + {"localhost", false, ""}, + {"0.0.0", false, ""}, + {"0.0.0.", false, ""}, + {"0.0.0.0.", false, ""}, + {"0.0.0.256", false, ""}, + {"0 . 0 . 0 . 0", false, ""}, + } + + devnull, _ := os.Open(os.DevNull) + os.Stderr = devnull + for i := range testCases { + var addr net.IP + f := setUpIP(&addr) + + tc := &testCases[i] + + arg := fmt.Sprintf("--address=%s", tc.input) + err := f.Parse([]string{arg}) + if err != nil && tc.success == true { + t.Errorf("expected success, got %q", err) + continue + } else if err == nil && tc.success == false { + t.Errorf("expected failure") + continue + } else if tc.success { + ip, err := f.GetIP("address") + if err != nil { + t.Errorf("Got error trying to fetch the IP flag: %v", err) + } + if ip.String() != tc.expected { + t.Errorf("expected %q, got %q", tc.expected, ip.String()) + } + } + } +} diff --git a/vendor/github.com/spf13/pflag/ipmask.go b/vendor/github.com/spf13/pflag/ipmask.go new file mode 100644 index 000000000..5bd44bd21 --- /dev/null +++ b/vendor/github.com/spf13/pflag/ipmask.go @@ -0,0 +1,122 @@ +package pflag + +import ( + "fmt" + "net" + "strconv" +) + +// -- net.IPMask value +type ipMaskValue net.IPMask + +func newIPMaskValue(val net.IPMask, p *net.IPMask) *ipMaskValue { + *p = val + return (*ipMaskValue)(p) +} + +func (i *ipMaskValue) String() string { return net.IPMask(*i).String() } +func (i *ipMaskValue) Set(s string) error { + ip := ParseIPv4Mask(s) + if ip == nil { + return fmt.Errorf("failed to parse IP mask: %q", s) + } + *i = ipMaskValue(ip) + return nil +} + +func (i *ipMaskValue) Type() string { + return "ipMask" +} + +// ParseIPv4Mask written in IP form (e.g. 255.255.255.0). +// This function should really belong to the net package. +func ParseIPv4Mask(s string) net.IPMask { + mask := net.ParseIP(s) + if mask == nil { + if len(s) != 8 { + return nil + } + // net.IPMask.String() actually outputs things like ffffff00 + // so write a horrible parser for that as well :-( + m := []int{} + for i := 0; i < 4; i++ { + b := "0x" + s[2*i:2*i+2] + d, err := strconv.ParseInt(b, 0, 0) + if err != nil { + return nil + } + m = append(m, int(d)) + } + s := fmt.Sprintf("%d.%d.%d.%d", m[0], m[1], m[2], m[3]) + mask = net.ParseIP(s) + if mask == nil { + return nil + } + } + return net.IPv4Mask(mask[12], mask[13], mask[14], mask[15]) +} + +func parseIPv4Mask(sval string) (interface{}, error) { + mask := ParseIPv4Mask(sval) + if mask == nil { + return nil, fmt.Errorf("unable to parse %s as net.IPMask", sval) + } + return mask, nil +} + +// GetIPv4Mask return the net.IPv4Mask value of a flag with the given name +func (f *FlagSet) GetIPv4Mask(name string) (net.IPMask, error) { + val, err := f.getFlagType(name, "ipMask", parseIPv4Mask) + if err != nil { + return nil, err + } + return val.(net.IPMask), nil +} + +// IPMaskVar defines an net.IPMask flag with specified name, default value, and usage string. +// The argument p points to an net.IPMask variable in which to store the value of the flag. +func (f *FlagSet) IPMaskVar(p *net.IPMask, name string, value net.IPMask, usage string) { + f.VarP(newIPMaskValue(value, p), name, "", usage) +} + +// IPMaskVarP is like IPMaskVar, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) IPMaskVarP(p *net.IPMask, name, shorthand string, value net.IPMask, usage string) { + f.VarP(newIPMaskValue(value, p), name, shorthand, usage) +} + +// IPMaskVar defines an net.IPMask flag with specified name, default value, and usage string. +// The argument p points to an net.IPMask variable in which to store the value of the flag. +func IPMaskVar(p *net.IPMask, name string, value net.IPMask, usage string) { + CommandLine.VarP(newIPMaskValue(value, p), name, "", usage) +} + +// IPMaskVarP is like IPMaskVar, but accepts a shorthand letter that can be used after a single dash. +func IPMaskVarP(p *net.IPMask, name, shorthand string, value net.IPMask, usage string) { + CommandLine.VarP(newIPMaskValue(value, p), name, shorthand, usage) +} + +// IPMask defines an net.IPMask flag with specified name, default value, and usage string. +// The return value is the address of an net.IPMask variable that stores the value of the flag. +func (f *FlagSet) IPMask(name string, value net.IPMask, usage string) *net.IPMask { + p := new(net.IPMask) + f.IPMaskVarP(p, name, "", value, usage) + return p +} + +// IPMaskP is like IPMask, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) IPMaskP(name, shorthand string, value net.IPMask, usage string) *net.IPMask { + p := new(net.IPMask) + f.IPMaskVarP(p, name, shorthand, value, usage) + return p +} + +// IPMask defines an net.IPMask flag with specified name, default value, and usage string. +// The return value is the address of an net.IPMask variable that stores the value of the flag. +func IPMask(name string, value net.IPMask, usage string) *net.IPMask { + return CommandLine.IPMaskP(name, "", value, usage) +} + +// IPMaskP is like IP, but accepts a shorthand letter that can be used after a single dash. +func IPMaskP(name, shorthand string, value net.IPMask, usage string) *net.IPMask { + return CommandLine.IPMaskP(name, shorthand, value, usage) +} diff --git a/vendor/github.com/spf13/pflag/ipnet.go b/vendor/github.com/spf13/pflag/ipnet.go new file mode 100644 index 000000000..149b764b1 --- /dev/null +++ b/vendor/github.com/spf13/pflag/ipnet.go @@ -0,0 +1,100 @@ +package pflag + +import ( + "fmt" + "net" + "strings" +) + +// IPNet adapts net.IPNet for use as a flag. +type ipNetValue net.IPNet + +func (ipnet ipNetValue) String() string { + n := net.IPNet(ipnet) + return n.String() +} + +func (ipnet *ipNetValue) Set(value string) error { + _, n, err := net.ParseCIDR(strings.TrimSpace(value)) + if err != nil { + return err + } + *ipnet = ipNetValue(*n) + return nil +} + +func (*ipNetValue) Type() string { + return "ipNet" +} + +var _ = strings.TrimSpace + +func newIPNetValue(val net.IPNet, p *net.IPNet) *ipNetValue { + *p = val + return (*ipNetValue)(p) +} + +func ipNetConv(sval string) (interface{}, error) { + _, n, err := net.ParseCIDR(strings.TrimSpace(sval)) + if err == nil { + return *n, nil + } + return nil, fmt.Errorf("invalid string being converted to IPNet: %s", sval) +} + +// GetIPNet return the net.IPNet value of a flag with the given name +func (f *FlagSet) GetIPNet(name string) (net.IPNet, error) { + val, err := f.getFlagType(name, "ipNet", ipNetConv) + if err != nil { + return net.IPNet{}, err + } + return val.(net.IPNet), nil +} + +// IPNetVar defines an net.IPNet flag with specified name, default value, and usage string. +// The argument p points to an net.IPNet variable in which to store the value of the flag. +func (f *FlagSet) IPNetVar(p *net.IPNet, name string, value net.IPNet, usage string) { + f.VarP(newIPNetValue(value, p), name, "", usage) +} + +// IPNetVarP is like IPNetVar, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) IPNetVarP(p *net.IPNet, name, shorthand string, value net.IPNet, usage string) { + f.VarP(newIPNetValue(value, p), name, shorthand, usage) +} + +// IPNetVar defines an net.IPNet flag with specified name, default value, and usage string. +// The argument p points to an net.IPNet variable in which to store the value of the flag. +func IPNetVar(p *net.IPNet, name string, value net.IPNet, usage string) { + CommandLine.VarP(newIPNetValue(value, p), name, "", usage) +} + +// IPNetVarP is like IPNetVar, but accepts a shorthand letter that can be used after a single dash. +func IPNetVarP(p *net.IPNet, name, shorthand string, value net.IPNet, usage string) { + CommandLine.VarP(newIPNetValue(value, p), name, shorthand, usage) +} + +// IPNet defines an net.IPNet flag with specified name, default value, and usage string. +// The return value is the address of an net.IPNet variable that stores the value of the flag. +func (f *FlagSet) IPNet(name string, value net.IPNet, usage string) *net.IPNet { + p := new(net.IPNet) + f.IPNetVarP(p, name, "", value, usage) + return p +} + +// IPNetP is like IPNet, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) IPNetP(name, shorthand string, value net.IPNet, usage string) *net.IPNet { + p := new(net.IPNet) + f.IPNetVarP(p, name, shorthand, value, usage) + return p +} + +// IPNet defines an net.IPNet flag with specified name, default value, and usage string. +// The return value is the address of an net.IPNet variable that stores the value of the flag. +func IPNet(name string, value net.IPNet, usage string) *net.IPNet { + return CommandLine.IPNetP(name, "", value, usage) +} + +// IPNetP is like IPNet, but accepts a shorthand letter that can be used after a single dash. +func IPNetP(name, shorthand string, value net.IPNet, usage string) *net.IPNet { + return CommandLine.IPNetP(name, shorthand, value, usage) +} diff --git a/vendor/github.com/spf13/pflag/ipnet_test.go b/vendor/github.com/spf13/pflag/ipnet_test.go new file mode 100644 index 000000000..335b6fa15 --- /dev/null +++ b/vendor/github.com/spf13/pflag/ipnet_test.go @@ -0,0 +1,70 @@ +package pflag + +import ( + "fmt" + "net" + "os" + "testing" +) + +func setUpIPNet(ip *net.IPNet) *FlagSet { + f := NewFlagSet("test", ContinueOnError) + _, def, _ := net.ParseCIDR("0.0.0.0/0") + f.IPNetVar(ip, "address", *def, "IP Address") + return f +} + +func TestIPNet(t *testing.T) { + testCases := []struct { + input string + success bool + expected string + }{ + {"0.0.0.0/0", true, "0.0.0.0/0"}, + {" 0.0.0.0/0 ", true, "0.0.0.0/0"}, + {"1.2.3.4/8", true, "1.0.0.0/8"}, + {"127.0.0.1/16", true, "127.0.0.0/16"}, + {"255.255.255.255/19", true, "255.255.224.0/19"}, + {"255.255.255.255/32", true, "255.255.255.255/32"}, + {"", false, ""}, + {"/0", false, ""}, + {"0", false, ""}, + {"0/0", false, ""}, + {"localhost/0", false, ""}, + {"0.0.0/4", false, ""}, + {"0.0.0./8", false, ""}, + {"0.0.0.0./12", false, ""}, + {"0.0.0.256/16", false, ""}, + {"0.0.0.0 /20", false, ""}, + {"0.0.0.0/ 24", false, ""}, + {"0 . 0 . 0 . 0 / 28", false, ""}, + {"0.0.0.0/33", false, ""}, + } + + devnull, _ := os.Open(os.DevNull) + os.Stderr = devnull + for i := range testCases { + var addr net.IPNet + f := setUpIPNet(&addr) + + tc := &testCases[i] + + arg := fmt.Sprintf("--address=%s", tc.input) + err := f.Parse([]string{arg}) + if err != nil && tc.success == true { + t.Errorf("expected success, got %q", err) + continue + } else if err == nil && tc.success == false { + t.Errorf("expected failure") + continue + } else if tc.success { + ip, err := f.GetIPNet("address") + if err != nil { + t.Errorf("Got error trying to fetch the IP flag: %v", err) + } + if ip.String() != tc.expected { + t.Errorf("expected %q, got %q", tc.expected, ip.String()) + } + } + } +} diff --git a/vendor/github.com/spf13/pflag/string.go b/vendor/github.com/spf13/pflag/string.go new file mode 100644 index 000000000..e296136e5 --- /dev/null +++ b/vendor/github.com/spf13/pflag/string.go @@ -0,0 +1,82 @@ +package pflag + +import "fmt" + +// -- string Value +type stringValue string + +func newStringValue(val string, p *string) *stringValue { + *p = val + return (*stringValue)(p) +} + +func (s *stringValue) Set(val string) error { + *s = stringValue(val) + return nil +} +func (s *stringValue) Type() string { + return "string" +} + +func (s *stringValue) String() string { return fmt.Sprintf("%s", *s) } + +func stringConv(sval string) (interface{}, error) { + return sval, nil +} + +// GetString return the string value of a flag with the given name +func (f *FlagSet) GetString(name string) (string, error) { + val, err := f.getFlagType(name, "string", stringConv) + if err != nil { + return "", err + } + return val.(string), nil +} + +// StringVar defines a string flag with specified name, default value, and usage string. +// The argument p points to a string variable in which to store the value of the flag. +func (f *FlagSet) StringVar(p *string, name string, value string, usage string) { + f.VarP(newStringValue(value, p), name, "", usage) +} + +// StringVarP is like StringVar, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) StringVarP(p *string, name, shorthand string, value string, usage string) { + f.VarP(newStringValue(value, p), name, shorthand, usage) +} + +// StringVar defines a string flag with specified name, default value, and usage string. +// The argument p points to a string variable in which to store the value of the flag. +func StringVar(p *string, name string, value string, usage string) { + CommandLine.VarP(newStringValue(value, p), name, "", usage) +} + +// StringVarP is like StringVar, but accepts a shorthand letter that can be used after a single dash. +func StringVarP(p *string, name, shorthand string, value string, usage string) { + CommandLine.VarP(newStringValue(value, p), name, shorthand, usage) +} + +// String defines a string flag with specified name, default value, and usage string. +// The return value is the address of a string variable that stores the value of the flag. +func (f *FlagSet) String(name string, value string, usage string) *string { + p := new(string) + f.StringVarP(p, name, "", value, usage) + return p +} + +// StringP is like String, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) StringP(name, shorthand string, value string, usage string) *string { + p := new(string) + f.StringVarP(p, name, shorthand, value, usage) + return p +} + +// String defines a string flag with specified name, default value, and usage string. +// The return value is the address of a string variable that stores the value of the flag. +func String(name string, value string, usage string) *string { + return CommandLine.StringP(name, "", value, usage) +} + +// StringP is like String, but accepts a shorthand letter that can be used after a single dash. +func StringP(name, shorthand string, value string, usage string) *string { + return CommandLine.StringP(name, shorthand, value, usage) +} diff --git a/vendor/github.com/spf13/pflag/string_slice.go b/vendor/github.com/spf13/pflag/string_slice.go new file mode 100644 index 000000000..b53648b2e --- /dev/null +++ b/vendor/github.com/spf13/pflag/string_slice.go @@ -0,0 +1,111 @@ +package pflag + +import ( + "encoding/csv" + "fmt" + "strings" +) + +var _ = fmt.Fprint + +// -- stringSlice Value +type stringSliceValue struct { + value *[]string + changed bool +} + +func newStringSliceValue(val []string, p *[]string) *stringSliceValue { + ssv := new(stringSliceValue) + ssv.value = p + *ssv.value = val + return ssv +} + +func (s *stringSliceValue) Set(val string) error { + stringReader := strings.NewReader(val) + csvReader := csv.NewReader(stringReader) + v, err := csvReader.Read() + if err != nil { + return err + } + if !s.changed { + *s.value = v + } else { + *s.value = append(*s.value, v...) + } + s.changed = true + return nil +} + +func (s *stringSliceValue) Type() string { + return "stringSlice" +} + +func (s *stringSliceValue) String() string { return "[" + strings.Join(*s.value, ",") + "]" } + +func stringSliceConv(sval string) (interface{}, error) { + sval = strings.Trim(sval, "[]") + // An empty string would cause a slice with one (empty) string + if len(sval) == 0 { + return []string{}, nil + } + v := strings.Split(sval, ",") + return v, nil +} + +// GetStringSlice return the []string value of a flag with the given name +func (f *FlagSet) GetStringSlice(name string) ([]string, error) { + val, err := f.getFlagType(name, "stringSlice", stringSliceConv) + if err != nil { + return []string{}, err + } + return val.([]string), nil +} + +// StringSliceVar defines a string flag with specified name, default value, and usage string. +// The argument p points to a []string variable in which to store the value of the flag. +func (f *FlagSet) StringSliceVar(p *[]string, name string, value []string, usage string) { + f.VarP(newStringSliceValue(value, p), name, "", usage) +} + +// StringSliceVarP is like StringSliceVar, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) StringSliceVarP(p *[]string, name, shorthand string, value []string, usage string) { + f.VarP(newStringSliceValue(value, p), name, shorthand, usage) +} + +// StringSliceVar defines a string flag with specified name, default value, and usage string. +// The argument p points to a []string variable in which to store the value of the flag. +func StringSliceVar(p *[]string, name string, value []string, usage string) { + CommandLine.VarP(newStringSliceValue(value, p), name, "", usage) +} + +// StringSliceVarP is like StringSliceVar, but accepts a shorthand letter that can be used after a single dash. +func StringSliceVarP(p *[]string, name, shorthand string, value []string, usage string) { + CommandLine.VarP(newStringSliceValue(value, p), name, shorthand, usage) +} + +// StringSlice defines a string flag with specified name, default value, and usage string. +// The return value is the address of a []string variable that stores the value of the flag. +func (f *FlagSet) StringSlice(name string, value []string, usage string) *[]string { + p := []string{} + f.StringSliceVarP(&p, name, "", value, usage) + return &p +} + +// StringSliceP is like StringSlice, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) StringSliceP(name, shorthand string, value []string, usage string) *[]string { + p := []string{} + f.StringSliceVarP(&p, name, shorthand, value, usage) + return &p +} + +// StringSlice defines a string flag with specified name, default value, and usage string. +// The return value is the address of a []string variable that stores the value of the flag. +func StringSlice(name string, value []string, usage string) *[]string { + return CommandLine.StringSliceP(name, "", value, usage) +} + +// StringSliceP is like StringSlice, but accepts a shorthand letter that can be used after a single dash. +func StringSliceP(name, shorthand string, value []string, usage string) *[]string { + return CommandLine.StringSliceP(name, shorthand, value, usage) +} diff --git a/vendor/github.com/spf13/pflag/string_slice_test.go b/vendor/github.com/spf13/pflag/string_slice_test.go new file mode 100644 index 000000000..c7fdc70b4 --- /dev/null +++ b/vendor/github.com/spf13/pflag/string_slice_test.go @@ -0,0 +1,161 @@ +// Copyright 2009 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package pflag + +import ( + "fmt" + "strings" + "testing" +) + +func setUpSSFlagSet(ssp *[]string) *FlagSet { + f := NewFlagSet("test", ContinueOnError) + f.StringSliceVar(ssp, "ss", []string{}, "Command separated list!") + return f +} + +func setUpSSFlagSetWithDefault(ssp *[]string) *FlagSet { + f := NewFlagSet("test", ContinueOnError) + f.StringSliceVar(ssp, "ss", []string{"default", "values"}, "Command separated list!") + return f +} + +func TestEmptySS(t *testing.T) { + var ss []string + f := setUpSSFlagSet(&ss) + err := f.Parse([]string{}) + if err != nil { + t.Fatal("expected no error; got", err) + } + + getSS, err := f.GetStringSlice("ss") + if err != nil { + t.Fatal("got an error from GetStringSlice():", err) + } + if len(getSS) != 0 { + t.Fatalf("got ss %v with len=%d but expected length=0", getSS, len(getSS)) + } +} + +func TestSS(t *testing.T) { + var ss []string + f := setUpSSFlagSet(&ss) + + vals := []string{"one", "two", "4", "3"} + arg := fmt.Sprintf("--ss=%s", strings.Join(vals, ",")) + err := f.Parse([]string{arg}) + if err != nil { + t.Fatal("expected no error; got", err) + } + for i, v := range ss { + if vals[i] != v { + t.Fatalf("expected ss[%d] to be %s but got: %s", i, vals[i], v) + } + } + + getSS, err := f.GetStringSlice("ss") + if err != nil { + t.Fatal("got an error from GetStringSlice():", err) + } + for i, v := range getSS { + if vals[i] != v { + t.Fatalf("expected ss[%d] to be %s from GetStringSlice but got: %s", i, vals[i], v) + } + } +} + +func TestSSDefault(t *testing.T) { + var ss []string + f := setUpSSFlagSetWithDefault(&ss) + + vals := []string{"default", "values"} + + err := f.Parse([]string{}) + if err != nil { + t.Fatal("expected no error; got", err) + } + for i, v := range ss { + if vals[i] != v { + t.Fatalf("expected ss[%d] to be %s but got: %s", i, vals[i], v) + } + } + + getSS, err := f.GetStringSlice("ss") + if err != nil { + t.Fatal("got an error from GetStringSlice():", err) + } + for i, v := range getSS { + if vals[i] != v { + t.Fatalf("expected ss[%d] to be %s from GetStringSlice but got: %s", i, vals[i], v) + } + } +} + +func TestSSWithDefault(t *testing.T) { + var ss []string + f := setUpSSFlagSetWithDefault(&ss) + + vals := []string{"one", "two", "4", "3"} + arg := fmt.Sprintf("--ss=%s", strings.Join(vals, ",")) + err := f.Parse([]string{arg}) + if err != nil { + t.Fatal("expected no error; got", err) + } + for i, v := range ss { + if vals[i] != v { + t.Fatalf("expected ss[%d] to be %s but got: %s", i, vals[i], v) + } + } + + getSS, err := f.GetStringSlice("ss") + if err != nil { + t.Fatal("got an error from GetStringSlice():", err) + } + for i, v := range getSS { + if vals[i] != v { + t.Fatalf("expected ss[%d] to be %s from GetStringSlice but got: %s", i, vals[i], v) + } + } +} + +func TestSSCalledTwice(t *testing.T) { + var ss []string + f := setUpSSFlagSet(&ss) + + in := []string{"one,two", "three"} + expected := []string{"one", "two", "three"} + argfmt := "--ss=%s" + arg1 := fmt.Sprintf(argfmt, in[0]) + arg2 := fmt.Sprintf(argfmt, in[1]) + err := f.Parse([]string{arg1, arg2}) + if err != nil { + t.Fatal("expected no error; got", err) + } + for i, v := range ss { + if expected[i] != v { + t.Fatalf("expected ss[%d] to be %s but got: %s", i, expected[i], v) + } + } +} + +func TestSSWithComma(t *testing.T) { + var ss []string + f := setUpSSFlagSet(&ss) + + in := []string{`"one,two"`, `"three"`} + expected := []string{"one,two", "three"} + argfmt := "--ss=%s" + arg1 := fmt.Sprintf(argfmt, in[0]) + arg2 := fmt.Sprintf(argfmt, in[1]) + err := f.Parse([]string{arg1, arg2}) + if err != nil { + t.Fatal("expected no error; got", err) + } + for i, v := range ss { + if expected[i] != v { + t.Fatalf("expected ss[%d] to be %s but got: %s", i, expected[i], v) + } + } +} diff --git a/vendor/github.com/spf13/pflag/uint.go b/vendor/github.com/spf13/pflag/uint.go new file mode 100644 index 000000000..e142b4996 --- /dev/null +++ b/vendor/github.com/spf13/pflag/uint.go @@ -0,0 +1,91 @@ +package pflag + +import ( + "fmt" + "strconv" +) + +// -- uint Value +type uintValue uint + +func newUintValue(val uint, p *uint) *uintValue { + *p = val + return (*uintValue)(p) +} + +func (i *uintValue) Set(s string) error { + v, err := strconv.ParseUint(s, 0, 64) + *i = uintValue(v) + return err +} + +func (i *uintValue) Type() string { + return "uint" +} + +func (i *uintValue) String() string { return fmt.Sprintf("%v", *i) } + +func uintConv(sval string) (interface{}, error) { + v, err := strconv.ParseUint(sval, 0, 0) + if err != nil { + return 0, err + } + return uint(v), nil +} + +// GetUint return the uint value of a flag with the given name +func (f *FlagSet) GetUint(name string) (uint, error) { + val, err := f.getFlagType(name, "uint", uintConv) + if err != nil { + return 0, err + } + return val.(uint), nil +} + +// UintVar defines a uint flag with specified name, default value, and usage string. +// The argument p points to a uint variable in which to store the value of the flag. +func (f *FlagSet) UintVar(p *uint, name string, value uint, usage string) { + f.VarP(newUintValue(value, p), name, "", usage) +} + +// UintVarP is like UintVar, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) UintVarP(p *uint, name, shorthand string, value uint, usage string) { + f.VarP(newUintValue(value, p), name, shorthand, usage) +} + +// UintVar defines a uint flag with specified name, default value, and usage string. +// The argument p points to a uint variable in which to store the value of the flag. +func UintVar(p *uint, name string, value uint, usage string) { + CommandLine.VarP(newUintValue(value, p), name, "", usage) +} + +// UintVarP is like UintVar, but accepts a shorthand letter that can be used after a single dash. +func UintVarP(p *uint, name, shorthand string, value uint, usage string) { + CommandLine.VarP(newUintValue(value, p), name, shorthand, usage) +} + +// Uint defines a uint flag with specified name, default value, and usage string. +// The return value is the address of a uint variable that stores the value of the flag. +func (f *FlagSet) Uint(name string, value uint, usage string) *uint { + p := new(uint) + f.UintVarP(p, name, "", value, usage) + return p +} + +// UintP is like Uint, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) UintP(name, shorthand string, value uint, usage string) *uint { + p := new(uint) + f.UintVarP(p, name, shorthand, value, usage) + return p +} + +// Uint defines a uint flag with specified name, default value, and usage string. +// The return value is the address of a uint variable that stores the value of the flag. +func Uint(name string, value uint, usage string) *uint { + return CommandLine.UintP(name, "", value, usage) +} + +// UintP is like Uint, but accepts a shorthand letter that can be used after a single dash. +func UintP(name, shorthand string, value uint, usage string) *uint { + return CommandLine.UintP(name, shorthand, value, usage) +} diff --git a/vendor/github.com/spf13/pflag/uint16.go b/vendor/github.com/spf13/pflag/uint16.go new file mode 100644 index 000000000..5c96c19dc --- /dev/null +++ b/vendor/github.com/spf13/pflag/uint16.go @@ -0,0 +1,89 @@ +package pflag + +import ( + "fmt" + "strconv" +) + +// -- uint16 value +type uint16Value uint16 + +func newUint16Value(val uint16, p *uint16) *uint16Value { + *p = val + return (*uint16Value)(p) +} +func (i *uint16Value) String() string { return fmt.Sprintf("%d", *i) } +func (i *uint16Value) Set(s string) error { + v, err := strconv.ParseUint(s, 0, 16) + *i = uint16Value(v) + return err +} + +func (i *uint16Value) Type() string { + return "uint16" +} + +func uint16Conv(sval string) (interface{}, error) { + v, err := strconv.ParseUint(sval, 0, 16) + if err != nil { + return 0, err + } + return uint16(v), nil +} + +// GetUint16 return the uint16 value of a flag with the given name +func (f *FlagSet) GetUint16(name string) (uint16, error) { + val, err := f.getFlagType(name, "uint16", uint16Conv) + if err != nil { + return 0, err + } + return val.(uint16), nil +} + +// Uint16Var defines a uint flag with specified name, default value, and usage string. +// The argument p points to a uint variable in which to store the value of the flag. +func (f *FlagSet) Uint16Var(p *uint16, name string, value uint16, usage string) { + f.VarP(newUint16Value(value, p), name, "", usage) +} + +// Uint16VarP is like Uint16Var, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) Uint16VarP(p *uint16, name, shorthand string, value uint16, usage string) { + f.VarP(newUint16Value(value, p), name, shorthand, usage) +} + +// Uint16Var defines a uint flag with specified name, default value, and usage string. +// The argument p points to a uint variable in which to store the value of the flag. +func Uint16Var(p *uint16, name string, value uint16, usage string) { + CommandLine.VarP(newUint16Value(value, p), name, "", usage) +} + +// Uint16VarP is like Uint16Var, but accepts a shorthand letter that can be used after a single dash. +func Uint16VarP(p *uint16, name, shorthand string, value uint16, usage string) { + CommandLine.VarP(newUint16Value(value, p), name, shorthand, usage) +} + +// Uint16 defines a uint flag with specified name, default value, and usage string. +// The return value is the address of a uint variable that stores the value of the flag. +func (f *FlagSet) Uint16(name string, value uint16, usage string) *uint16 { + p := new(uint16) + f.Uint16VarP(p, name, "", value, usage) + return p +} + +// Uint16P is like Uint16, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) Uint16P(name, shorthand string, value uint16, usage string) *uint16 { + p := new(uint16) + f.Uint16VarP(p, name, shorthand, value, usage) + return p +} + +// Uint16 defines a uint flag with specified name, default value, and usage string. +// The return value is the address of a uint variable that stores the value of the flag. +func Uint16(name string, value uint16, usage string) *uint16 { + return CommandLine.Uint16P(name, "", value, usage) +} + +// Uint16P is like Uint16, but accepts a shorthand letter that can be used after a single dash. +func Uint16P(name, shorthand string, value uint16, usage string) *uint16 { + return CommandLine.Uint16P(name, shorthand, value, usage) +} diff --git a/vendor/github.com/spf13/pflag/uint32.go b/vendor/github.com/spf13/pflag/uint32.go new file mode 100644 index 000000000..294fcaa32 --- /dev/null +++ b/vendor/github.com/spf13/pflag/uint32.go @@ -0,0 +1,89 @@ +package pflag + +import ( + "fmt" + "strconv" +) + +// -- uint16 value +type uint32Value uint32 + +func newUint32Value(val uint32, p *uint32) *uint32Value { + *p = val + return (*uint32Value)(p) +} +func (i *uint32Value) String() string { return fmt.Sprintf("%d", *i) } +func (i *uint32Value) Set(s string) error { + v, err := strconv.ParseUint(s, 0, 32) + *i = uint32Value(v) + return err +} + +func (i *uint32Value) Type() string { + return "uint32" +} + +func uint32Conv(sval string) (interface{}, error) { + v, err := strconv.ParseUint(sval, 0, 32) + if err != nil { + return 0, err + } + return uint32(v), nil +} + +// GetUint32 return the uint32 value of a flag with the given name +func (f *FlagSet) GetUint32(name string) (uint32, error) { + val, err := f.getFlagType(name, "uint32", uint32Conv) + if err != nil { + return 0, err + } + return val.(uint32), nil +} + +// Uint32Var defines a uint32 flag with specified name, default value, and usage string. +// The argument p points to a uint32 variable in which to store the value of the flag. +func (f *FlagSet) Uint32Var(p *uint32, name string, value uint32, usage string) { + f.VarP(newUint32Value(value, p), name, "", usage) +} + +// Uint32VarP is like Uint32Var, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) Uint32VarP(p *uint32, name, shorthand string, value uint32, usage string) { + f.VarP(newUint32Value(value, p), name, shorthand, usage) +} + +// Uint32Var defines a uint32 flag with specified name, default value, and usage string. +// The argument p points to a uint32 variable in which to store the value of the flag. +func Uint32Var(p *uint32, name string, value uint32, usage string) { + CommandLine.VarP(newUint32Value(value, p), name, "", usage) +} + +// Uint32VarP is like Uint32Var, but accepts a shorthand letter that can be used after a single dash. +func Uint32VarP(p *uint32, name, shorthand string, value uint32, usage string) { + CommandLine.VarP(newUint32Value(value, p), name, shorthand, usage) +} + +// Uint32 defines a uint32 flag with specified name, default value, and usage string. +// The return value is the address of a uint32 variable that stores the value of the flag. +func (f *FlagSet) Uint32(name string, value uint32, usage string) *uint32 { + p := new(uint32) + f.Uint32VarP(p, name, "", value, usage) + return p +} + +// Uint32P is like Uint32, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) Uint32P(name, shorthand string, value uint32, usage string) *uint32 { + p := new(uint32) + f.Uint32VarP(p, name, shorthand, value, usage) + return p +} + +// Uint32 defines a uint32 flag with specified name, default value, and usage string. +// The return value is the address of a uint32 variable that stores the value of the flag. +func Uint32(name string, value uint32, usage string) *uint32 { + return CommandLine.Uint32P(name, "", value, usage) +} + +// Uint32P is like Uint32, but accepts a shorthand letter that can be used after a single dash. +func Uint32P(name, shorthand string, value uint32, usage string) *uint32 { + return CommandLine.Uint32P(name, shorthand, value, usage) +} diff --git a/vendor/github.com/spf13/pflag/uint64.go b/vendor/github.com/spf13/pflag/uint64.go new file mode 100644 index 000000000..c68188505 --- /dev/null +++ b/vendor/github.com/spf13/pflag/uint64.go @@ -0,0 +1,91 @@ +package pflag + +import ( + "fmt" + "strconv" +) + +// -- uint64 Value +type uint64Value uint64 + +func newUint64Value(val uint64, p *uint64) *uint64Value { + *p = val + return (*uint64Value)(p) +} + +func (i *uint64Value) Set(s string) error { + v, err := strconv.ParseUint(s, 0, 64) + *i = uint64Value(v) + return err +} + +func (i *uint64Value) Type() string { + return "uint64" +} + +func (i *uint64Value) String() string { return fmt.Sprintf("%v", *i) } + +func uint64Conv(sval string) (interface{}, error) { + v, err := strconv.ParseUint(sval, 0, 64) + if err != nil { + return 0, err + } + return uint64(v), nil +} + +// GetUint64 return the uint64 value of a flag with the given name +func (f *FlagSet) GetUint64(name string) (uint64, error) { + val, err := f.getFlagType(name, "uint64", uint64Conv) + if err != nil { + return 0, err + } + return val.(uint64), nil +} + +// Uint64Var defines a uint64 flag with specified name, default value, and usage string. +// The argument p points to a uint64 variable in which to store the value of the flag. +func (f *FlagSet) Uint64Var(p *uint64, name string, value uint64, usage string) { + f.VarP(newUint64Value(value, p), name, "", usage) +} + +// Uint64VarP is like Uint64Var, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) Uint64VarP(p *uint64, name, shorthand string, value uint64, usage string) { + f.VarP(newUint64Value(value, p), name, shorthand, usage) +} + +// Uint64Var defines a uint64 flag with specified name, default value, and usage string. +// The argument p points to a uint64 variable in which to store the value of the flag. +func Uint64Var(p *uint64, name string, value uint64, usage string) { + CommandLine.VarP(newUint64Value(value, p), name, "", usage) +} + +// Uint64VarP is like Uint64Var, but accepts a shorthand letter that can be used after a single dash. +func Uint64VarP(p *uint64, name, shorthand string, value uint64, usage string) { + CommandLine.VarP(newUint64Value(value, p), name, shorthand, usage) +} + +// Uint64 defines a uint64 flag with specified name, default value, and usage string. +// The return value is the address of a uint64 variable that stores the value of the flag. +func (f *FlagSet) Uint64(name string, value uint64, usage string) *uint64 { + p := new(uint64) + f.Uint64VarP(p, name, "", value, usage) + return p +} + +// Uint64P is like Uint64, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) Uint64P(name, shorthand string, value uint64, usage string) *uint64 { + p := new(uint64) + f.Uint64VarP(p, name, shorthand, value, usage) + return p +} + +// Uint64 defines a uint64 flag with specified name, default value, and usage string. +// The return value is the address of a uint64 variable that stores the value of the flag. +func Uint64(name string, value uint64, usage string) *uint64 { + return CommandLine.Uint64P(name, "", value, usage) +} + +// Uint64P is like Uint64, but accepts a shorthand letter that can be used after a single dash. +func Uint64P(name, shorthand string, value uint64, usage string) *uint64 { + return CommandLine.Uint64P(name, shorthand, value, usage) +} diff --git a/vendor/github.com/spf13/pflag/uint8.go b/vendor/github.com/spf13/pflag/uint8.go new file mode 100644 index 000000000..26db418ad --- /dev/null +++ b/vendor/github.com/spf13/pflag/uint8.go @@ -0,0 +1,91 @@ +package pflag + +import ( + "fmt" + "strconv" +) + +// -- uint8 Value +type uint8Value uint8 + +func newUint8Value(val uint8, p *uint8) *uint8Value { + *p = val + return (*uint8Value)(p) +} + +func (i *uint8Value) Set(s string) error { + v, err := strconv.ParseUint(s, 0, 8) + *i = uint8Value(v) + return err +} + +func (i *uint8Value) Type() string { + return "uint8" +} + +func (i *uint8Value) String() string { return fmt.Sprintf("%v", *i) } + +func uint8Conv(sval string) (interface{}, error) { + v, err := strconv.ParseUint(sval, 0, 8) + if err != nil { + return 0, err + } + return uint8(v), nil +} + +// GetUint8 return the uint8 value of a flag with the given name +func (f *FlagSet) GetUint8(name string) (uint8, error) { + val, err := f.getFlagType(name, "uint8", uint8Conv) + if err != nil { + return 0, err + } + return val.(uint8), nil +} + +// Uint8Var defines a uint8 flag with specified name, default value, and usage string. +// The argument p points to a uint8 variable in which to store the value of the flag. +func (f *FlagSet) Uint8Var(p *uint8, name string, value uint8, usage string) { + f.VarP(newUint8Value(value, p), name, "", usage) +} + +// Uint8VarP is like Uint8Var, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) Uint8VarP(p *uint8, name, shorthand string, value uint8, usage string) { + f.VarP(newUint8Value(value, p), name, shorthand, usage) +} + +// Uint8Var defines a uint8 flag with specified name, default value, and usage string. +// The argument p points to a uint8 variable in which to store the value of the flag. +func Uint8Var(p *uint8, name string, value uint8, usage string) { + CommandLine.VarP(newUint8Value(value, p), name, "", usage) +} + +// Uint8VarP is like Uint8Var, but accepts a shorthand letter that can be used after a single dash. +func Uint8VarP(p *uint8, name, shorthand string, value uint8, usage string) { + CommandLine.VarP(newUint8Value(value, p), name, shorthand, usage) +} + +// Uint8 defines a uint8 flag with specified name, default value, and usage string. +// The return value is the address of a uint8 variable that stores the value of the flag. +func (f *FlagSet) Uint8(name string, value uint8, usage string) *uint8 { + p := new(uint8) + f.Uint8VarP(p, name, "", value, usage) + return p +} + +// Uint8P is like Uint8, but accepts a shorthand letter that can be used after a single dash. +func (f *FlagSet) Uint8P(name, shorthand string, value uint8, usage string) *uint8 { + p := new(uint8) + f.Uint8VarP(p, name, shorthand, value, usage) + return p +} + +// Uint8 defines a uint8 flag with specified name, default value, and usage string. +// The return value is the address of a uint8 variable that stores the value of the flag. +func Uint8(name string, value uint8, usage string) *uint8 { + return CommandLine.Uint8P(name, "", value, usage) +} + +// Uint8P is like Uint8, but accepts a shorthand letter that can be used after a single dash. +func Uint8P(name, shorthand string, value uint8, usage string) *uint8 { + return CommandLine.Uint8P(name, shorthand, value, usage) +} diff --git a/vendor/github.com/spf13/pflag/verify/all.sh b/vendor/github.com/spf13/pflag/verify/all.sh new file mode 100755 index 000000000..739f89c0b --- /dev/null +++ b/vendor/github.com/spf13/pflag/verify/all.sh @@ -0,0 +1,69 @@ +#!/bin/bash + +set -o errexit +set -o nounset +set -o pipefail + +ROOT=$(dirname "${BASH_SOURCE}")/.. + +# Some useful colors. +if [[ -z "${color_start-}" ]]; then + declare -r color_start="\033[" + declare -r color_red="${color_start}0;31m" + declare -r color_yellow="${color_start}0;33m" + declare -r color_green="${color_start}0;32m" + declare -r color_norm="${color_start}0m" +fi + +SILENT=true + +function is-excluded { + for e in $EXCLUDE; do + if [[ $1 -ef ${BASH_SOURCE} ]]; then + return + fi + if [[ $1 -ef "$ROOT/hack/$e" ]]; then + return + fi + done + return 1 +} + +while getopts ":v" opt; do + case $opt in + v) + SILENT=false + ;; + \?) + echo "Invalid flag: -$OPTARG" >&2 + exit 1 + ;; + esac +done + +if $SILENT ; then + echo "Running in the silent mode, run with -v if you want to see script logs." +fi + +EXCLUDE="all.sh" + +ret=0 +for t in `ls $ROOT/verify/*.sh` +do + if is-excluded $t ; then + echo "Skipping $t" + continue + fi + if $SILENT ; then + echo -e "Verifying $t" + if bash "$t" &> /dev/null; then + echo -e "${color_green}SUCCESS${color_norm}" + else + echo -e "${color_red}FAILED${color_norm}" + ret=1 + fi + else + bash "$t" || ret=1 + fi +done +exit $ret diff --git a/vendor/github.com/spf13/pflag/verify/gofmt.sh b/vendor/github.com/spf13/pflag/verify/gofmt.sh new file mode 100755 index 000000000..f66acf803 --- /dev/null +++ b/vendor/github.com/spf13/pflag/verify/gofmt.sh @@ -0,0 +1,19 @@ +#!/bin/bash + +set -o errexit +set -o nounset +set -o pipefail + +ROOT=$(dirname "${BASH_SOURCE}")/.. + +pushd "${ROOT}" > /dev/null + +GOFMT=${GOFMT:-"gofmt"} +bad_files=$(find . -name '*.go' | xargs $GOFMT -s -l) +if [[ -n "${bad_files}" ]]; then + echo "!!! '$GOFMT' needs to be run on the following files: " + echo "${bad_files}" + exit 1 +fi + +# ex: ts=2 sw=2 et filetype=sh diff --git a/vendor/github.com/spf13/pflag/verify/golint.sh b/vendor/github.com/spf13/pflag/verify/golint.sh new file mode 100755 index 000000000..685c1778e --- /dev/null +++ b/vendor/github.com/spf13/pflag/verify/golint.sh @@ -0,0 +1,15 @@ +#!/bin/bash + +ROOT=$(dirname "${BASH_SOURCE}")/.. +GOLINT=${GOLINT:-"golint"} + +pushd "${ROOT}" > /dev/null + bad_files=$($GOLINT -min_confidence=0.9 ./...) + if [[ -n "${bad_files}" ]]; then + echo "!!! '$GOLINT' problems: " + echo "${bad_files}" + exit 1 + fi +popd > /dev/null + +# ex: ts=2 sw=2 et filetype=sh From 0779d250ad7123e178ad303fd841a0125c18c347 Mon Sep 17 00:00:00 2001 From: Dongsu Park Date: Tue, 17 May 2016 10:30:38 +0200 Subject: [PATCH 3/6] fleetctl: do not pass around cAPI Let's roll back to the original global variable cAPI, to keep the entire code as simple as possible. As this is a single command-line tool, it would be harmless to simply use a global variable. --- fleetctl/fleetctl.go | 75 ++++++++++++++++---------------- fleetctl/fleetctl_test.go | 6 +-- fleetctl/journal.go | 2 +- fleetctl/list_unit_files.go | 20 ++++----- fleetctl/list_unit_files_test.go | 25 +++++------ fleetctl/list_units.go | 18 ++++---- fleetctl/list_units_test.go | 14 +++--- fleetctl/load.go | 6 +-- fleetctl/load_test.go | 2 +- fleetctl/ssh.go | 22 +++++----- fleetctl/ssh_test.go | 32 +++++++------- fleetctl/start.go | 6 +-- fleetctl/start_test.go | 2 +- fleetctl/status.go | 2 +- fleetctl/stop.go | 4 +- fleetctl/stop_test.go | 2 +- fleetctl/submit.go | 2 +- fleetctl/submit_test.go | 2 +- fleetctl/unload.go | 4 +- fleetctl/unload_test.go | 2 +- 20 files changed, 123 insertions(+), 125 deletions(-) diff --git a/fleetctl/fleetctl.go b/fleetctl/fleetctl.go index e7491091a..9fd30fd1a 100644 --- a/fleetctl/fleetctl.go +++ b/fleetctl/fleetctl.go @@ -69,7 +69,7 @@ var ( out *tabwriter.Writer // global API client used by commands - // cAPI client.API + cAPI client.API // current command being executed currentCommand string @@ -195,15 +195,6 @@ func main() { app.Run(os.Args) } -func getClientAPI(c *cli.Context) client.API { - cAPI, err := getClient(c) - if err != nil { - stderr("Unable to initialize client: %v", err) - os.Exit(1) - } - return cAPI -} - func makeActionWrapper(action func(context *cli.Context, cAPI client.API) int) func(context *cli.Context) { return func(c *cli.Context) { if c.Bool("sign") { @@ -239,6 +230,16 @@ func getFlagsFromEnv(prefix string, fs *flag.FlagSet) { }) } +func getClientAPI(c *cli.Context) client.API { + var err error + cAPI, err = getClient(c) + if err != nil { + stderr("Unable to initialize client: %v", err) + os.Exit(1) + } + return cAPI +} + // getClient initializes a client of fleet based on CLI flags func getClient(c *cli.Context) (client.API, error) { driverFlag := c.GlobalString("driver") @@ -430,7 +431,7 @@ func getChecker(c *cli.Context) *ssh.HostKeyChecker { // tries to get the template configuration either from the registry or // the local disk. // It returns a UnitFile configuration or nil; and any error ecountered -func getUnitFile(file string, cAPI client.API, c *cli.Context) (*unit.UnitFile, error) { +func getUnitFile(file string, c *cli.Context) (*unit.UnitFile, error) { var uf *unit.UnitFile name := unitNameMangle(file) @@ -458,7 +459,7 @@ func getUnitFile(file string, cAPI client.API, c *cli.Context) (*unit.UnitFile, // If we found a template unit, later we create a // near-identical instance unit in the Registry - same // unit file as the template, but different name - uf, err = getUnitFileFromTemplate(info, file, cAPI, c) + uf, err = getUnitFileFromTemplate(info, file, c) if err != nil { return nil, fmt.Errorf("failed getting Unit(%s) from template: %v", file, err) } @@ -486,7 +487,7 @@ func getUnitFromFile(file string) (*unit.UnitFile, error) { // is either in the registry or on the file system // It takes two arguments, the template information and the unit file name // It returns the Unit or nil; and any error encountered -func getUnitFileFromTemplate(uni *unit.UnitNameInfo, fileName string, cAPI client.API, c *cli.Context) (*unit.UnitFile, error) { +func getUnitFileFromTemplate(uni *unit.UnitNameInfo, fileName string, c *cli.Context) (*unit.UnitFile, error) { var uf *unit.UnitFile tmpl, err := cAPI.Unit(uni.Template) @@ -547,7 +548,7 @@ func machineFullLegend(ms machine.MachineState, full bool) string { return legend } -func findUnits(args []string, cAPI client.API) (sus []schema.Unit, err error) { +func findUnits(args []string) (sus []schema.Unit, err error) { units, err := cAPI.Units() if err != nil { return nil, err @@ -572,7 +573,7 @@ func findUnits(args []string, cAPI client.API) (sus []schema.Unit, err error) { return filtered, nil } -func createUnit(name string, uf *unit.UnitFile, cAPI client.API) (*schema.Unit, error) { +func createUnit(name string, uf *unit.UnitFile) (*schema.Unit, error) { if uf == nil { return nil, fmt.Errorf("nil unit provided") } @@ -647,7 +648,7 @@ func checkReplaceUnitState(unit *schema.Unit) (int, error) { // It takes a unit file path as a parameter. // It returns 0 on success and if the unit should be created, 1 if the // unit should not be created; and any error encountered. -func checkUnitCreation(arg string, c *cli.Context, cAPI client.API) (int, error) { +func checkUnitCreation(arg string, c *cli.Context) (int, error) { name := unitNameMangle(arg) // First, check if there already exists a Unit by the given name in the Registry @@ -695,7 +696,7 @@ func checkUnitCreation(arg string, c *cli.Context, cAPI client.API) (int, error) // Any error encountered during these steps is returned immediately (i.e. // subsequent Jobs are not acted on). An error is also returned if none of the // above conditions match a given Job. -func lazyCreateUnits(c *cli.Context, cAPI client.API) error { +func lazyCreateUnits(c *cli.Context) error { args := c.Args() errchan := make(chan error) var wg sync.WaitGroup @@ -703,7 +704,7 @@ func lazyCreateUnits(c *cli.Context, cAPI client.API) error { arg = maybeAppendDefaultUnitType(arg) name := unitNameMangle(arg) - ret, err := checkUnitCreation(arg, c, cAPI) + ret, err := checkUnitCreation(arg, c) if err != nil { return err } else if ret != 0 { @@ -713,18 +714,18 @@ func lazyCreateUnits(c *cli.Context, cAPI client.API) error { // Assume that the name references a local unit file on // disk or if it is an instance unit and if so get its // corresponding unit - uf, err := getUnitFile(arg, cAPI, c) + uf, err := getUnitFile(arg, c) if err != nil { return err } - _, err = createUnit(name, uf, cAPI) + _, err = createUnit(name, uf) if err != nil { return err } wg.Add(1) - go checkUnitState(name, job.JobStateInactive, c.Int("block-attempts"), os.Stdout, &wg, errchan, cAPI) + go checkUnitState(name, job.JobStateInactive, c.Int("block-attempts"), os.Stdout, &wg, errchan) } go func() { @@ -808,27 +809,27 @@ func isLocalUnitDifferent(file string, su *schema.Unit, fatal bool, c *cli.Conte return false, err } -func lazyLoadUnits(args []string, cAPI client.API) ([]*schema.Unit, error) { +func lazyLoadUnits(args []string) ([]*schema.Unit, error) { units := make([]string, 0, len(args)) for _, j := range args { units = append(units, unitNameMangle(j)) } - return setTargetStateOfUnits(units, job.JobStateLoaded, cAPI) + return setTargetStateOfUnits(units, job.JobStateLoaded) } -func lazyStartUnits(args []string, cAPI client.API) ([]*schema.Unit, error) { +func lazyStartUnits(args []string) ([]*schema.Unit, error) { units := make([]string, 0, len(args)) for _, j := range args { units = append(units, unitNameMangle(j)) } - return setTargetStateOfUnits(units, job.JobStateLaunched, cAPI) + return setTargetStateOfUnits(units, job.JobStateLaunched) } // setTargetStateOfUnits ensures that the target state for the given Units is set // to the given state in the Registry. // On success, a slice of the Units for which a state change was made is returned. // Any error encountered is immediately returned (i.e. this is not a transaction). -func setTargetStateOfUnits(units []string, state job.JobState, cAPI client.API) ([]*schema.Unit, error) { +func setTargetStateOfUnits(units []string, state job.JobState) ([]*schema.Unit, error) { triggered := make([]*schema.Unit, 0) for _, name := range units { u, err := cAPI.Unit(name) @@ -881,7 +882,7 @@ func getBlockAttempts(c *cli.Context) int { // If maxAttempts is zero tryWaitForUnitStates will retry forever, and // if it is greater than zero, it will retry up to the indicated value. // It returns 0 on success or 1 on errors. -func tryWaitForUnitStates(units []string, state string, js job.JobState, maxAttempts int, out io.Writer, cAPI client.API) (ret int) { +func tryWaitForUnitStates(units []string, state string, js job.JobState, maxAttempts int, out io.Writer) (ret int) { // We do not wait just assume we reached the desired state if maxAttempts <= -1 { for _, name := range units { @@ -890,7 +891,7 @@ func tryWaitForUnitStates(units []string, state string, js job.JobState, maxAtte return } - errchan := waitForUnitStates(units, js, maxAttempts, out, cAPI) + errchan := waitForUnitStates(units, js, maxAttempts, out) for err := range errchan { stderr("Error waiting for units: %v", err) ret = 1 @@ -906,12 +907,12 @@ func tryWaitForUnitStates(units []string, state string, js job.JobState, maxAtte // than zero. Returned is an error channel used to communicate when // timeouts occur. The returned error channel will be closed after all // polling operation is complete. -func waitForUnitStates(units []string, js job.JobState, maxAttempts int, out io.Writer, cAPI client.API) chan error { +func waitForUnitStates(units []string, js job.JobState, maxAttempts int, out io.Writer) chan error { errchan := make(chan error) var wg sync.WaitGroup for _, name := range units { wg.Add(1) - go checkUnitState(name, js, maxAttempts, out, &wg, errchan, cAPI) + go checkUnitState(name, js, maxAttempts, out, &wg, errchan) } go func() { @@ -922,21 +923,21 @@ func waitForUnitStates(units []string, js job.JobState, maxAttempts int, out io. return errchan } -func checkUnitState(name string, js job.JobState, maxAttempts int, out io.Writer, wg *sync.WaitGroup, errchan chan error, cAPI client.API) { +func checkUnitState(name string, js job.JobState, maxAttempts int, out io.Writer, wg *sync.WaitGroup, errchan chan error) { defer wg.Done() sleep := defaultSleepTime if maxAttempts < 1 { for { - if assertUnitState(name, js, out, cAPI) { + if assertUnitState(name, js, out) { return } time.Sleep(sleep) } } else { for attempt := 0; attempt < maxAttempts; attempt++ { - if assertUnitState(name, js, out, cAPI) { + if assertUnitState(name, js, out) { return } time.Sleep(sleep) @@ -945,7 +946,7 @@ func checkUnitState(name string, js job.JobState, maxAttempts int, out io.Writer } } -func assertUnitState(name string, js job.JobState, out io.Writer, cAPI client.API) (ret bool) { +func assertUnitState(name string, js job.JobState, out io.Writer) (ret bool) { var state string u, err := cAPI.Unit(name) @@ -974,7 +975,7 @@ func assertUnitState(name string, js job.JobState, out io.Writer, cAPI client.AP msg := fmt.Sprintf("Unit %s %s", name, u.CurrentState) if u.MachineID != "" { - ms := cachedMachineState(u.MachineID, cAPI) + ms := cachedMachineState(u.MachineID) if ms != nil { msg = fmt.Sprintf("%s on %s", msg, machineFullLegend(*ms, false)) } @@ -984,7 +985,7 @@ func assertUnitState(name string, js job.JobState, out io.Writer, cAPI client.AP return } -func machineState(machID string, cAPI client.API) (*machine.MachineState, error) { +func machineState(machID string) (*machine.MachineState, error) { machines, err := cAPI.Machines() if err != nil { return nil, err @@ -1000,7 +1001,7 @@ func machineState(machID string, cAPI client.API) (*machine.MachineState, error) // cachedMachineState makes a best-effort to retrieve the MachineState of the given machine ID. // It memoizes MachineState information for the life of a fleetctl invocation. // Any error encountered retrieving the list of machines is ignored. -func cachedMachineState(machID string, cAPI client.API) (ms *machine.MachineState) { +func cachedMachineState(machID string) (ms *machine.MachineState) { if machineStates == nil { machineStates = make(map[string]*machine.MachineState) ms, err := cAPI.Machines() diff --git a/fleetctl/fleetctl_test.go b/fleetctl/fleetctl_test.go index b126e4965..ace7f8180 100644 --- a/fleetctl/fleetctl_test.go +++ b/fleetctl/fleetctl_test.go @@ -26,8 +26,8 @@ import ( "github.com/coreos/fleet/unit" "github.com/coreos/fleet/version" - "github.com/coreos/go-semver/semver" "github.com/codegangsta/cli" + "github.com/coreos/go-semver/semver" ) type commandTestResults struct { @@ -281,7 +281,7 @@ func TestCreateUnitFails(t *testing.T) { type fakeAPI struct { client.API } - cAPI := fakeAPI{} + cAPI = fakeAPI{} var i int var un string var uf *unit.UnitFile @@ -348,7 +348,7 @@ Conflicts=bar`), for i, tt = range testCases { un = tt.name uf = tt.uf - if _, err := createUnit(un, uf, cAPI); err == nil { + if _, err := createUnit(un, uf); err == nil { t.Errorf("case %d did not return error as expected!", i) t.Logf("unit name: %v", un) t.Logf("unit file: %#v", uf) diff --git a/fleetctl/journal.go b/fleetctl/journal.go index d0a249039..b3fcca522 100644 --- a/fleetctl/journal.go +++ b/fleetctl/journal.go @@ -81,5 +81,5 @@ func runJournal(c *cli.Context, cAPI client.API) (exit int) { cmd = append(cmd, "-f") } - return runCommand(c, cAPI, u.MachineID, cmd[0], cmd[1:]...) + return runCommand(c, u.MachineID, cmd[0], cmd[1:]...) } diff --git a/fleetctl/list_unit_files.go b/fleetctl/list_unit_files.go index 4a74be94c..1c9d2bc03 100644 --- a/fleetctl/list_unit_files.go +++ b/fleetctl/list_unit_files.go @@ -31,14 +31,14 @@ const ( defaultListUnitFilesFields = "unit,hash,dstate,state,target" ) -func mapTargetField(u schema.Unit, full bool, cAPI client.API) string { +func mapTargetField(u schema.Unit, full bool) string { if suToGlobal(u) { return "global" } if u.MachineID == "" { return "-" } - ms := cachedMachineState(u.MachineID, cAPI) + ms := cachedMachineState(u.MachineID) if ms == nil { ms = &machine.MachineState{ID: u.MachineID} } @@ -63,13 +63,13 @@ func NewListUnitFilesCommand() cli.Command { var ( listUnitFilesFields = map[string]unitToField{ - "unit": func(u schema.Unit, full bool, cAPI client.API) string { + "unit": func(u schema.Unit, full bool) string { return u.Name }, - "global": func(u schema.Unit, full bool, cAPI client.API) string { + "global": func(u schema.Unit, full bool) string { return strconv.FormatBool(suToGlobal(u)) }, - "dstate": func(u schema.Unit, full bool, cAPI client.API) string { + "dstate": func(u schema.Unit, full bool) string { if u.DesiredState == "" { return "-" } @@ -77,20 +77,20 @@ var ( }, "target": mapTargetField, "tmachine": mapTargetField, - "state": func(u schema.Unit, full bool, cAPI client.API) string { + "state": func(u schema.Unit, full bool) string { if suToGlobal(u) || u.CurrentState == "" { return "-" } return u.CurrentState }, - "hash": func(u schema.Unit, full bool, cAPI client.API) string { + "hash": func(u schema.Unit, full bool) string { uf := schema.MapSchemaUnitOptionsToUnitFile(u.Options) if !full { return uf.Hash().Short() } return uf.Hash().String() }, - "desc": func(u schema.Unit, full bool, cAPI client.API) string { + "desc": func(u schema.Unit, full bool) string { uf := schema.MapSchemaUnitOptionsToUnitFile(u.Options) d := uf.Description() if d == "" { @@ -101,7 +101,7 @@ var ( } ) -type unitToField func(u schema.Unit, full bool, cAPI client.API) string +type unitToField func(u schema.Unit, full bool) string func runListUnitFiles(c *cli.Context, cAPI client.API) (exit int) { listUnitFilesFieldsFlag := c.String("fields") @@ -134,7 +134,7 @@ func runListUnitFiles(c *cli.Context, cAPI client.API) (exit int) { for _, u := range units { var f []string for _, col := range cols { - f = append(f, listUnitFilesFields[col](*u, c.Bool("full"), cAPI)) + f = append(f, listUnitFilesFields[col](*u, c.Bool("full"))) } fmt.Fprintln(out, strings.Join(f, "\t")) } diff --git a/fleetctl/list_unit_files_test.go b/fleetctl/list_unit_files_test.go index e99782394..ca9785d6d 100644 --- a/fleetctl/list_unit_files_test.go +++ b/fleetctl/list_unit_files_test.go @@ -24,13 +24,10 @@ import ( ) func TestListUnitFilesFieldsToStrings(t *testing.T) { - // c := createTestContext(t) - // stderr("Context: %v",c) - // cAPI := getClientAPI(c) type fakeAPI struct { client.API } - cAPI := fakeAPI{} + cAPI = fakeAPI{} u := schema.Unit{ Name: "foo.service", Options: []*schema.UnitOption{}, @@ -43,11 +40,11 @@ func TestListUnitFilesFieldsToStrings(t *testing.T) { "tmachine": "-", "state": "-", } { - f := listUnitFilesFields[k](u, false, cAPI) + f := listUnitFilesFields[k](u, false) assertEqual(t, k, v, f) } - f := listUnitFilesFields["unit"](u, false, cAPI) + f := listUnitFilesFields["unit"](u, false) assertEqual(t, "unit", u.Name, f) u = schema.Unit{ @@ -57,12 +54,12 @@ func TestListUnitFilesFieldsToStrings(t *testing.T) { }, } - d := listUnitFilesFields["desc"](u, false, cAPI) + d := listUnitFilesFields["desc"](u, false) assertEqual(t, "desc", "some description", d) for _, state := range []job.JobState{job.JobStateLoaded, job.JobStateInactive, job.JobStateLaunched} { u.CurrentState = string(state) - f := listUnitFilesFields["state"](u, false, cAPI) + f := listUnitFilesFields["state"](u, false) assertEqual(t, "state", string(state), f) } @@ -70,7 +67,7 @@ func TestListUnitFilesFieldsToStrings(t *testing.T) { machineStates = map[string]*machine.MachineState{} u.MachineID = "some-id" - ms := listUnitFilesFields["tmachine"](u, true, cAPI) + ms := listUnitFilesFields["tmachine"](u, true) assertEqual(t, "machine", "some-id", ms) u.MachineID = "other-id" @@ -80,12 +77,12 @@ func TestListUnitFilesFieldsToStrings(t *testing.T) { PublicIP: "1.2.3.4", }, } - ms = listUnitFilesFields["tmachine"](u, true, cAPI) + ms = listUnitFilesFields["tmachine"](u, true) assertEqual(t, "machine", "other-id/1.2.3.4", ms) uh := "a0f275d46bc6ee0eca06be7c339913c07d99c0c7" - fuh := listUnitFilesFields["hash"](u, true, cAPI) - suh := listUnitFilesFields["hash"](u, false, cAPI) + fuh := listUnitFilesFields["hash"](u, true) + suh := listUnitFilesFields["hash"](u, false) assertEqual(t, "hash", uh, fuh) assertEqual(t, "hash", uh[:7], suh) } @@ -94,7 +91,7 @@ func TestMapTargetField(t *testing.T) { type fakeAPI struct { client.API } - cAPI := fakeAPI{} + cAPI = fakeAPI{} // seeding the cache for the following test cases machineStates = map[string]*machine.MachineState{ "XXX": &machine.MachineState{ID: "XXX"}, @@ -129,7 +126,7 @@ func TestMapTargetField(t *testing.T) { for i, tt := range tests { // eliminate the "full" variable from test cases by hard-coding "true" below - got := mapTargetField(tt.unit, true, cAPI) + got := mapTargetField(tt.unit, true) if tt.want != got { t.Errorf("case %d: want=%q got=%q", i, tt.want, got) } diff --git a/fleetctl/list_units.go b/fleetctl/list_units.go index 403c3fb3f..d82b85c60 100644 --- a/fleetctl/list_units.go +++ b/fleetctl/list_units.go @@ -56,41 +56,41 @@ Or, choose the columns to display: var ( listUnitsFields = map[string]usToField{ - "unit": func(us *schema.UnitState, full bool, cAPI client.API) string { + "unit": func(us *schema.UnitState, full bool) string { if us == nil { return "-" } return us.Name }, - "load": func(us *schema.UnitState, full bool, cAPI client.API) string { + "load": func(us *schema.UnitState, full bool) string { if us == nil { return "-" } return us.SystemdLoadState }, - "active": func(us *schema.UnitState, full bool, cAPI client.API) string { + "active": func(us *schema.UnitState, full bool) string { if us == nil { return "-" } return us.SystemdActiveState }, - "sub": func(us *schema.UnitState, full bool, cAPI client.API) string { + "sub": func(us *schema.UnitState, full bool) string { if us == nil { return "-" } return us.SystemdSubState }, - "machine": func(us *schema.UnitState, full bool, cAPI client.API) string { + "machine": func(us *schema.UnitState, full bool) string { if us == nil || us.MachineID == "" { return "-" } - ms := cachedMachineState(us.MachineID, cAPI) + ms := cachedMachineState(us.MachineID) if ms == nil { ms = &machine.MachineState{ID: us.MachineID} } return machineFullLegend(*ms, full) }, - "hash": func(us *schema.UnitState, full bool, cAPI client.API) string { + "hash": func(us *schema.UnitState, full bool) string { if us == nil || us.Hash == "" { return "-" } @@ -102,7 +102,7 @@ var ( } ) -type usToField func(us *schema.UnitState, full bool, cAPI client.API) string +type usToField func(us *schema.UnitState, full bool) string func runListUnits(c *cli.Context, cAPI client.API) (exit int) { listUnitsFieldsFlag := c.String("fields") @@ -132,7 +132,7 @@ func runListUnits(c *cli.Context, cAPI client.API) (exit int) { for _, us := range states { var f []string for _, col := range cols { - f = append(f, listUnitsFields[col](us, c.Bool("full"), cAPI)) + f = append(f, listUnitsFields[col](us, c.Bool("full"))) } fmt.Fprintln(out, strings.Join(f, "\t")) } diff --git a/fleetctl/list_units_test.go b/fleetctl/list_units_test.go index 99de255aa..cb1394b11 100644 --- a/fleetctl/list_units_test.go +++ b/fleetctl/list_units_test.go @@ -40,11 +40,11 @@ func TestListUnitsFieldsToStrings(t *testing.T) { type fakeAPI struct { client.API } - cAPI := fakeAPI{} + cAPI = fakeAPI{} // nil UnitState shouldn't happen, but just in case for _, tt := range []string{"unit", "load", "active", "sub", "machine", "hash"} { - f := listUnitsFields[tt](nil, false, cAPI) + f := listUnitsFields[tt](nil, false) assertEqual(t, tt, "-", f) } @@ -63,12 +63,12 @@ func TestListUnitsFieldsToStrings(t *testing.T) { "machine": "-", "unit": "sleep", } { - got := listUnitsFields[k](us, false, cAPI) + got := listUnitsFields[k](us, false) assertEqual(t, k, want, got) } us.MachineID = "some-id" - ms := listUnitsFields["machine"](us, true, cAPI) + ms := listUnitsFields["machine"](us, true) assertEqual(t, "machine", "some-id", ms) us.MachineID = "other-id" @@ -78,13 +78,13 @@ func TestListUnitsFieldsToStrings(t *testing.T) { PublicIP: "1.2.3.4", }, } - ms = listUnitsFields["machine"](us, true, cAPI) + ms = listUnitsFields["machine"](us, true) assertEqual(t, "machine", "other-id/1.2.3.4", ms) uh := "a0f275d46bc6ee0eca06be7c339913c07d99c0c7" us.Hash = uh - fuh := listUnitsFields["hash"](us, true, cAPI) - suh := listUnitsFields["hash"](us, false, cAPI) + fuh := listUnitsFields["hash"](us, true) + suh := listUnitsFields["hash"](us, false) assertEqual(t, "hash", uh, fuh) assertEqual(t, "hash", uh[:7], suh) } diff --git a/fleetctl/load.go b/fleetctl/load.go index a72df158d..977825da4 100644 --- a/fleetctl/load.go +++ b/fleetctl/load.go @@ -55,12 +55,12 @@ func runLoadUnits(c *cli.Context, cAPI client.API) (exit int) { return 0 } - if err := lazyCreateUnits(c, cAPI); err != nil { + if err := lazyCreateUnits(c); err != nil { stderr("Error creating units: %v", err) return 1 } - triggered, err := lazyLoadUnits(args, cAPI) + triggered, err := lazyLoadUnits(args) if err != nil { stderr("Error loading units: %v", err) return 1 @@ -75,7 +75,7 @@ func runLoadUnits(c *cli.Context, cAPI client.API) (exit int) { } } - exit = tryWaitForUnitStates(loading, "load", job.JobStateLoaded, getBlockAttempts(c), os.Stdout, cAPI) + exit = tryWaitForUnitStates(loading, "load", job.JobStateLoaded, getBlockAttempts(c), os.Stdout) return } diff --git a/fleetctl/load_test.go b/fleetctl/load_test.go index b27337a10..97201a3da 100644 --- a/fleetctl/load_test.go +++ b/fleetctl/load_test.go @@ -45,7 +45,7 @@ func doLoadUnits(t *testing.T, r commandTestResults, errchan chan error, cAPI cl return } - real_units, err := findUnits(r.units, cAPI) + real_units, err := findUnits(r.units) if err != nil { errchan <- err return diff --git a/fleetctl/ssh.go b/fleetctl/ssh.go index dc0cd56dd..caf2a1c20 100644 --- a/fleetctl/ssh.go +++ b/fleetctl/ssh.go @@ -80,11 +80,11 @@ func runSSH(c *cli.Context, cAPI client.API) (exit int) { switch { case c.String("machine") != "": - addr, _, err = findAddressInMachineList(c.String("machine"), cAPI) + addr, _, err = findAddressInMachineList(c.String("machine")) case c.String("unit") != "": - addr, _, err = findAddressInRunningUnits(c.String("unit"), cAPI) + addr, _, err = findAddressInRunningUnits(c.String("unit")) default: - addr, err = globalMachineLookup(args, cAPI) + addr, err = globalMachineLookup(args) // trim machine/unit name from args if len(args) > 0 { args = args[1:] @@ -143,15 +143,15 @@ func findSSHPort(addr string, c *cli.Context) string { } } -func globalMachineLookup(args []string, cAPI client.API) (string, error) { +func globalMachineLookup(args []string) (string, error) { if len(args) == 0 { return "", errors.New("one machine or unit must be provided") } lookup := args[0] - machineAddr, machineOk, _ := findAddressInMachineList(lookup, cAPI) - unitAddr, unitOk, _ := findAddressInRunningUnits(lookup, cAPI) + machineAddr, machineOk, _ := findAddressInMachineList(lookup) + unitAddr, unitOk, _ := findAddressInRunningUnits(lookup) switch { case machineOk && unitOk: @@ -165,7 +165,7 @@ func globalMachineLookup(args []string, cAPI client.API) (string, error) { return "", fmt.Errorf("could not find matching unit or machine") } -func findAddressInMachineList(lookup string, cAPI client.API) (string, bool, error) { +func findAddressInMachineList(lookup string) (string, bool, error) { states, err := cAPI.Machines() if err != nil { return "", false, err @@ -192,7 +192,7 @@ func findAddressInMachineList(lookup string, cAPI client.API) (string, bool, err return match.PublicIP, true, nil } -func findAddressInRunningUnits(name string, cAPI client.API) (string, bool, error) { +func findAddressInRunningUnits(name string) (string, bool, error) { name = unitNameMangle(name) u, err := cAPI.Unit(name) if err != nil { @@ -203,7 +203,7 @@ func findAddressInRunningUnits(name string, cAPI client.API) (string, bool, erro return "", false, fmt.Errorf("global units unsupported") } - m := cachedMachineState(u.MachineID, cAPI) + m := cachedMachineState(u.MachineID) if m != nil && m.PublicIP != "" { return m.PublicIP, true, nil } @@ -213,7 +213,7 @@ func findAddressInRunningUnits(name string, cAPI client.API) (string, bool, erro // runCommand will attempt to run a command on a given machine. It will attempt // to SSH to the machine if it is identified as being remote. -func runCommand(c *cli.Context, cAPI client.API, machID string, cmd string, args ...string) (retcode int) { +func runCommand(c *cli.Context, machID string, cmd string, args ...string) (retcode int) { var err error if machine.IsLocalMachineID(machID) { err, retcode = runLocalCommand(cmd, args...) @@ -221,7 +221,7 @@ func runCommand(c *cli.Context, cAPI client.API, machID string, cmd string, args stderr("Error running local command: %v", err) } } else { - ms, err := machineState(machID, cAPI) + ms, err := machineState(machID) if err != nil || ms == nil { stderr("Error getting machine IP: %v", err) } else { diff --git a/fleetctl/ssh_test.go b/fleetctl/ssh_test.go index 980993ac2..0e5845b18 100644 --- a/fleetctl/ssh_test.go +++ b/fleetctl/ssh_test.go @@ -80,54 +80,54 @@ func newFakeRegistryForSsh() client.API { } func TestSshUnknownMachine(t *testing.T) { - cAPI := newFakeRegistryForSsh() + cAPI = newFakeRegistryForSsh() - _, ok, _ := findAddressInMachineList("asdf", cAPI) + _, ok, _ := findAddressInMachineList("asdf") if ok { t.Error("Expected to not find any machine with the machine ID `asdf`") } } func TestSshFindMachine(t *testing.T) { - cAPI := newFakeRegistryForSsh() + cAPI = newFakeRegistryForSsh() - ip, _, _ := findAddressInMachineList("c31e44e1-f858-436e-933e-59c642517860", cAPI) + ip, _, _ := findAddressInMachineList("c31e44e1-f858-436e-933e-59c642517860") if ip != "1.2.3.4" { t.Errorf("Expected to return the host 1.2.3.4, but it was %s", ip) } } func TestSshFindMachineByUnknownUnitName(t *testing.T) { - cAPI := newFakeRegistryForSsh() + cAPI = newFakeRegistryForSsh() - _, ok, _ := findAddressInRunningUnits("asdf", cAPI) + _, ok, _ := findAddressInRunningUnits("asdf") if ok { t.Error("Expected to not find any machine with the unit name `asdf`") } } func TestSshFindMachineByUnitName(t *testing.T) { - cAPI := newFakeRegistryForSsh() + cAPI = newFakeRegistryForSsh() - ip, _, _ := findAddressInRunningUnits("j1", cAPI) + ip, _, _ := findAddressInRunningUnits("j1") if ip != "1.2.3.4" { t.Errorf("Expected to return the host 1.2.3.4, but it was %s", ip) } } func TestGlobalLookupByUnknownArgument(t *testing.T) { - cAPI := newFakeRegistryForSsh() + cAPI = newFakeRegistryForSsh() - _, err := globalMachineLookup([]string{"asdf"}, cAPI) + _, err := globalMachineLookup([]string{"asdf"}) if err == nil { t.Fatal("Expected to receive error, got nil") } } func TestGlobalLookupByMachineID(t *testing.T) { - cAPI := newFakeRegistryForSsh() + cAPI = newFakeRegistryForSsh() - ip, err := globalMachineLookup([]string{"c31e44e1-f858-436e-933e-59c642517860"}, cAPI) + ip, err := globalMachineLookup([]string{"c31e44e1-f858-436e-933e-59c642517860"}) if err != nil { t.Fatal("Expected to not find any error") } @@ -138,9 +138,9 @@ func TestGlobalLookupByMachineID(t *testing.T) { } func TestGlobalLookupByUnitName(t *testing.T) { - cAPI := newFakeRegistryForSsh() + cAPI = newFakeRegistryForSsh() - ip, err := globalMachineLookup([]string{"j1"}, cAPI) + ip, err := globalMachineLookup([]string{"j1"}) if err != nil { t.Fatal("Expected to not find any error") } @@ -151,9 +151,9 @@ func TestGlobalLookupByUnitName(t *testing.T) { } func TestGlobalLookupWithAmbiguousArgument(t *testing.T) { - cAPI := newFakeRegistryForSsh() + cAPI = newFakeRegistryForSsh() - _, err := globalMachineLookup([]string{"hello.service"}, cAPI) + _, err := globalMachineLookup([]string{"hello.service"}) if err == nil { t.Fatal("Expected to find an error with an ambiguous argument") } diff --git a/fleetctl/start.go b/fleetctl/start.go index 790542ce9..2ad4ce690 100644 --- a/fleetctl/start.go +++ b/fleetctl/start.go @@ -61,12 +61,12 @@ func runStartUnit(c *cli.Context, cAPI client.API) (exit int) { return 0 } - if err := lazyCreateUnits(c, cAPI); err != nil { + if err := lazyCreateUnits(c); err != nil { stderr("Error creating units: %v", err) return 1 } - triggered, err := lazyStartUnits(args, cAPI) + triggered, err := lazyStartUnits(args) if err != nil { stderr("Error starting units: %v", err) return 1 @@ -81,6 +81,6 @@ func runStartUnit(c *cli.Context, cAPI client.API) (exit int) { } } - exit = tryWaitForUnitStates(starting, "start", job.JobStateLaunched, getBlockAttempts(c), os.Stdout, cAPI) + exit = tryWaitForUnitStates(starting, "start", job.JobStateLaunched, getBlockAttempts(c), os.Stdout) return } diff --git a/fleetctl/start_test.go b/fleetctl/start_test.go index 98cdb64e0..70830a48c 100644 --- a/fleetctl/start_test.go +++ b/fleetctl/start_test.go @@ -44,7 +44,7 @@ func doStartUnits(t *testing.T, r commandTestResults, errchan chan error, cAPI c return } - real_units, err := findUnits(r.units, cAPI) + real_units, err := findUnits(r.units) if err != nil { errchan <- err return diff --git a/fleetctl/status.go b/fleetctl/status.go index 273135aae..ef9cacf7e 100644 --- a/fleetctl/status.go +++ b/fleetctl/status.go @@ -72,7 +72,7 @@ func runStatusUnits(c *cli.Context, cAPI client.API) (exit int) { fmt.Printf("\n") } - if exit = runCommand(c, cAPI, unit.MachineID, "systemctl", "status", "-l", unit.Name); exit != 0 { + if exit = runCommand(c, unit.MachineID, "systemctl", "status", "-l", unit.Name); exit != 0 { break } } diff --git a/fleetctl/stop.go b/fleetctl/stop.go index f09864bd9..7ba790ead 100644 --- a/fleetctl/stop.go +++ b/fleetctl/stop.go @@ -61,7 +61,7 @@ func runStopUnit(c *cli.Context, cAPI client.API) (exit int) { return 0 } - units, err := findUnits(args, cAPI) + units, err := findUnits(args) if err != nil { stderr("%v", err) return 1 @@ -88,7 +88,7 @@ func runStopUnit(c *cli.Context, cAPI client.API) (exit int) { } } - exit = tryWaitForUnitStates(stopping, "stop", job.JobStateLoaded, getBlockAttempts(c), os.Stdout, cAPI) + exit = tryWaitForUnitStates(stopping, "stop", job.JobStateLoaded, getBlockAttempts(c), os.Stdout) if exit == 0 { stderr("Successfully stopped units %v.", stopping) } else { diff --git a/fleetctl/stop_test.go b/fleetctl/stop_test.go index df047140b..5e2dd5b1b 100644 --- a/fleetctl/stop_test.go +++ b/fleetctl/stop_test.go @@ -32,7 +32,7 @@ func doStopUnits(t *testing.T, r commandTestResults, errchan chan error, cAPI cl return } - real_units, err := findUnits(r.units, cAPI) + real_units, err := findUnits(r.units) if err != nil { errchan <- err return diff --git a/fleetctl/submit.go b/fleetctl/submit.go index 333123bfb..fc55aaaf9 100644 --- a/fleetctl/submit.go +++ b/fleetctl/submit.go @@ -49,7 +49,7 @@ func runSubmitUnits(c *cli.Context, cAPI client.API) (exit int) { return 0 } - if err := lazyCreateUnits(c, cAPI); err != nil { + if err := lazyCreateUnits(c); err != nil { stderr("Error creating units: %v", err) exit = 1 } diff --git a/fleetctl/submit_test.go b/fleetctl/submit_test.go index f6d791477..04c937011 100644 --- a/fleetctl/submit_test.go +++ b/fleetctl/submit_test.go @@ -31,7 +31,7 @@ func doSubmitUnits(t *testing.T, r commandTestResults, errchan chan error, cAPI return } - submitted, err := findUnits(r.units, cAPI) + submitted, err := findUnits(r.units) if err != nil { errchan <- err return diff --git a/fleetctl/unload.go b/fleetctl/unload.go index 486dcf55f..d7a98fdea 100644 --- a/fleetctl/unload.go +++ b/fleetctl/unload.go @@ -44,7 +44,7 @@ func runUnloadUnit(c *cli.Context, cAPI client.API) (exit int) { return 0 } - units, err := findUnits(args, cAPI) + units, err := findUnits(args) if err != nil { stderr("%v", err) return 1 @@ -68,7 +68,7 @@ func runUnloadUnit(c *cli.Context, cAPI client.API) (exit int) { } } - exit = tryWaitForUnitStates(wait, "unload", job.JobStateInactive, getBlockAttempts(c), os.Stdout, cAPI) + exit = tryWaitForUnitStates(wait, "unload", job.JobStateInactive, getBlockAttempts(c), os.Stdout) if exit == 0 { stderr("Successfully unloaded units %v.", wait) } else { diff --git a/fleetctl/unload_test.go b/fleetctl/unload_test.go index fe68782e4..67f0bdad8 100644 --- a/fleetctl/unload_test.go +++ b/fleetctl/unload_test.go @@ -32,7 +32,7 @@ func doUnloadUnits(t *testing.T, r commandTestResults, errchan chan error, cAPI return } - real_units, err := findUnits(r.units, cAPI) + real_units, err := findUnits(r.units) if err != nil { errchan <- err return From 848d35616fc95d58bdd7771c60f1a7c90c747a33 Mon Sep 17 00:00:00 2001 From: Dongsu Park Date: Fri, 20 May 2016 09:41:25 +0200 Subject: [PATCH 4/6] fleetctl: convert cli to cobra Use Cobra (github.com/spf13/cobra) instead of cli (github.com/codegangsta/cli), for better cmdline user interface. * Create a wrapper runWrapper() to be used for cobra, to wrap around a normal run*() function into a prototype for cobra.Command.Run(). It also sets a global variable cAPI for running a normal command. * remove unnecessary code for codegangsta/cli from fleetctl.go. Suggested-by: Jonathan Boulle Fixes: https://github.com/coreos/fleet/issues/1453 Supersedes https://github.com/coreos/fleet/pull/1570 --- fleetctl/cat.go | 24 +-- fleetctl/destroy.go | 31 ++- fleetctl/fdforward.go | 24 ++- fleetctl/fleetctl.go | 366 ++++++++++++++++++++++-------------- fleetctl/help.go | 129 +++++++++++++ fleetctl/journal.go | 58 +++--- fleetctl/list_machines.go | 70 +++---- fleetctl/list_unit_files.go | 50 ++--- fleetctl/list_units.go | 69 +++---- fleetctl/load.go | 44 ++--- fleetctl/ssh.go | 99 +++++----- fleetctl/start.go | 51 ++--- fleetctl/status.go | 33 ++-- fleetctl/stop.go | 37 ++-- fleetctl/submit.go | 43 ++--- fleetctl/unload.go | 30 ++- fleetctl/verify.go | 21 +-- fleetctl/version.go | 37 ++++ 18 files changed, 742 insertions(+), 474 deletions(-) create mode 100644 fleetctl/help.go create mode 100644 fleetctl/version.go diff --git a/fleetctl/cat.go b/fleetctl/cat.go index 82b578096..f7107e1bc 100644 --- a/fleetctl/cat.go +++ b/fleetctl/cat.go @@ -17,24 +17,24 @@ package main import ( "fmt" - "github.com/codegangsta/cli" + "github.com/spf13/cobra" - "github.com/coreos/fleet/client" "github.com/coreos/fleet/schema" ) -func NewCatCommand() cli.Command { - return cli.Command{ - Name: "cat", - Usage: "Output the contents of a submitted unit", - ArgsUsage: "UNIT", - Description: `Outputs the unit file that is currently loaded in the cluster. Useful to verify the correct version of a unit is running.`, - Action: makeActionWrapper(runCatUnit), - } +var cmdCat = &cobra.Command{ + Use: "cat UNIT", + Short: "Output the contents of a submitted unit", + Long: `Outputs the unit file that is currently loaded in the cluster. Useful to verify +the correct version of a unit is running.`, + Run: runWrapper(runCatUnit), +} + +func init() { + cmdFleet.AddCommand(cmdCat) } -func runCatUnit(c *cli.Context, cAPI client.API) (exit int) { - args := c.Args() +func runCatUnit(cCmd *cobra.Command, args []string) (exit int) { if len(args) != 1 { stderr("One unit file must be provided") return 1 diff --git a/fleetctl/destroy.go b/fleetctl/destroy.go index b8bf9a441..0e6f1685a 100644 --- a/fleetctl/destroy.go +++ b/fleetctl/destroy.go @@ -17,35 +17,35 @@ package main import ( "time" - "github.com/codegangsta/cli" + "github.com/spf13/cobra" "github.com/coreos/fleet/client" ) -func NewDestroyCommand() cli.Command { - return cli.Command{ - Name: "destroy", - Usage: "Destroy one or more units in the cluster", - ArgsUsage: "UNIT...", - Description: `Completely remove one or more running or submitted units from the cluster. +var cmdDestroy = &cobra.Command{ + Use: "destroy UNIT...", + Short: "Destroy one or more units in the cluster", + Long: `Completely remove one or more running or submitted units from the cluster. Instructs systemd on the host machine to stop the unit, deferring to systemd completely for any custom stop directives (i.e. ExecStop option in the unit file). Destroyed units are impossible to start unless re-submitted.`, - Action: makeActionWrapper(runDestroyUnits), - } + Run: runWrapper(runDestroyUnit), +} + +func init() { + cmdFleet.AddCommand(cmdDestroy) } -func runDestroyUnits(c *cli.Context, cAPI client.API) (exit int) { - args := c.Args() +func runDestroyUnit(cCmd *cobra.Command, args []string) (exit int) { if len(args) == 0 { stderr("No units given") return 0 } - units, err := findUnits(args, cAPI) + units, err := findUnits(args) if err != nil { stderr("%v", err) return 1 @@ -63,10 +63,10 @@ func runDestroyUnits(c *cli.Context, cAPI client.API) (exit int) { continue } - if c.Bool("no-block") { - attempts := c.Int("block-attempts") + if sharedFlags.NoBlock { + attempts := sharedFlags.BlockAttempts retry := func() bool { - if c.Int("block-attempts") < 1 { + if sharedFlags.BlockAttempts < 1 { return true } attempts-- @@ -93,6 +93,5 @@ func runDestroyUnits(c *cli.Context, cAPI client.API) (exit int) { stdout("Destroyed %s", v.Name) } - return } diff --git a/fleetctl/fdforward.go b/fleetctl/fdforward.go index 55f8b255f..d12e52b17 100644 --- a/fleetctl/fdforward.go +++ b/fleetctl/fdforward.go @@ -19,23 +19,21 @@ import ( "net" "os" - "github.com/codegangsta/cli" - - "github.com/coreos/fleet/client" + "github.com/spf13/cobra" ) -func NewFDForwardCommand() cli.Command { - return cli.Command{ - Name: "fd-forward", - Usage: "Proxy stdin and stdout to a unix domain socket", - ArgsUsage: "SOCKET", - Description: `fleetctl utilizes fd-forward when --tunnel is used and --endpoint is a unix socket. This command is not intended to be called by users directly.`, - Action: makeActionWrapper(runFDForward), - } +var cmdFDForward = &cobra.Command{ + Use: "fd-forward SOCKET", + Short: "Proxy stdin and stdout to a unix domain socket", + Long: `fleetctl utilizes fd-forward when --tunnel is used and --endpoint is a unix socket. This command is not intended to be called by users directly.`, + Run: runWrapper(runFDForward), +} + +func init() { + cmdFleet.AddCommand(cmdFDForward) } -func runFDForward(c *cli.Context, cAPI client.API) (exit int) { - args := c.Args() +func runFDForward(cCmd *cobra.Command, args []string) (exit int) { if len(args) != 1 { stderr("Provide a single argument") return 1 diff --git a/fleetctl/fleetctl.go b/fleetctl/fleetctl.go index 9fd30fd1a..18dd5e408 100644 --- a/fleetctl/fleetctl.go +++ b/fleetctl/fleetctl.go @@ -30,7 +30,7 @@ import ( "text/tabwriter" "time" - "github.com/codegangsta/cli" + "github.com/spf13/cobra" etcd "github.com/coreos/etcd/client" @@ -68,19 +68,119 @@ recommended to upgrade fleetctl to prevent incompatibility issues. var ( out *tabwriter.Writer + // set of top-level commands + commands []*Command + // global API client used by commands cAPI client.API + // flags used by all commands + globalFlags = struct { + Debug bool + Version bool + Help bool + + ClientDriver string + ExperimentalAPI bool + Endpoint string + RequestTimeout float64 + + KeyFile string + CertFile string + CAFile string + + Tunnel string + KnownHostsFile string + StrictHostKeyChecking bool + SSHTimeout float64 + SSHUserName string + + EtcdKeyPrefix string + }{} + + // flags used by multiple commands + sharedFlags = struct { + Sign bool + Full bool + NoLegend bool + NoBlock bool + Replace bool + BlockAttempts int + Fields string + SSHPort int + }{} + // current command being executed currentCommand string // used to cache MachineStates machineStates map[string]*machine.MachineState + + cmdExitCode int ) +var cmdFleet = &cobra.Command{ + Use: cliName, + Short: cliDescription, + // SuggestFor: []string{"fleetctl"}, + Run: func(cCmd *cobra.Command, args []string) { + cCmd.HelpFunc()(cCmd, args) + }, +} + func init() { - out = new(tabwriter.Writer) - out.Init(os.Stdout, 0, 8, 1, '\t', 0) + out = getTabOutWithWriter(os.Stdout) + + // call this as early as possible to ensure we always have timestamps + // on fleetctl logs + log.EnableTimestamps() + + cobra.EnablePrefixMatching = true + + cmdFleet.PersistentFlags().BoolVar(&globalFlags.Help, "help", false, "Print usage information and exit") + cmdFleet.PersistentFlags().BoolVar(&globalFlags.Help, "h", false, "Print usage information and exit") + + cmdFleet.PersistentFlags().BoolVar(&globalFlags.Debug, "debug", false, "Print out more debug information to stderr") + cmdFleet.PersistentFlags().BoolVar(&globalFlags.Version, "version", false, "Print the version and exit") + cmdFleet.PersistentFlags().StringVar(&globalFlags.ClientDriver, "driver", clientDriverAPI, fmt.Sprintf("Adapter used to execute fleetctl commands. Options include %q and %q.", clientDriverAPI, clientDriverEtcd)) + cmdFleet.PersistentFlags().StringVar(&globalFlags.Endpoint, "endpoint", defaultEndpoint, fmt.Sprintf("Location of the fleet API if --driver=%s. Alternatively, if --driver=%s, location of the etcd API.", clientDriverAPI, clientDriverEtcd)) + cmdFleet.PersistentFlags().StringVar(&globalFlags.EtcdKeyPrefix, "etcd-key-prefix", registry.DefaultKeyPrefix, "Keyspace for fleet data in etcd (development use only!)") + + cmdFleet.PersistentFlags().StringVar(&globalFlags.KeyFile, "key-file", "", "Location of TLS key file used to secure communication with the fleet API or etcd") + cmdFleet.PersistentFlags().StringVar(&globalFlags.CertFile, "cert-file", "", "Location of TLS cert file used to secure communication with the fleet API or etcd") + cmdFleet.PersistentFlags().StringVar(&globalFlags.CAFile, "ca-file", "", "Location of TLS CA file used to secure communication with the fleet API or etcd") + + cmdFleet.PersistentFlags().StringVar(&globalFlags.KnownHostsFile, "known-hosts-file", ssh.DefaultKnownHostsFile, "File used to store remote machine fingerprints. Ignored if strict host key checking is disabled.") + cmdFleet.PersistentFlags().BoolVar(&globalFlags.StrictHostKeyChecking, "strict-host-key-checking", true, "Verify host keys presented by remote machines before initiating SSH connections.") + cmdFleet.PersistentFlags().Float64Var(&globalFlags.SSHTimeout, "ssh-timeout", 10.0, "Amount of time in seconds to allow for SSH connection initialization before failing.") + cmdFleet.PersistentFlags().StringVar(&globalFlags.Tunnel, "tunnel", "", "Establish an SSH tunnel through the provided address for communication with fleet and etcd.") + cmdFleet.PersistentFlags().Float64Var(&globalFlags.RequestTimeout, "request-timeout", 3.0, "Amount of time in seconds to allow a single request before considering it failed.") + cmdFleet.PersistentFlags().StringVar(&globalFlags.SSHUserName, "ssh-username", "core", "Username to use when connecting to CoreOS instance.") + + // deprecated flags + cmdFleet.PersistentFlags().BoolVar(&globalFlags.ExperimentalAPI, "experimental-api", true, "DEPRECATED: do not use this flag.") + cmdFleet.PersistentFlags().StringVar(&globalFlags.KeyFile, "etcd-keyfile", "", "DEPRECATED: do not use this flag.") + cmdFleet.PersistentFlags().StringVar(&globalFlags.CertFile, "etcd-certfile", "", "DEPRECATED: do not use this flag.") + cmdFleet.PersistentFlags().StringVar(&globalFlags.CAFile, "etcd-cafile", "", "DEPRECATED: do not use this flag.") +} + +type Command struct { + Name string // Name of the Command and the string to use to invoke it + Summary string // One-sentence summary of what the Command does + Usage string // Usage options/arguments + Description string // Detailed description of command + Flags flag.FlagSet // Set of flags associated with this command + + Run func(args []string) int // Run a command with the given arguments, return exit status + +} + +func getFlags(flagset *flag.FlagSet) (flags []*flag.Flag) { + flags = make([]*flag.Flag, 0) + flagset.VisitAll(func(f *flag.Flag) { + flags = append(flags, f) + }) + return } func maybeAddNewline(s string) string { @@ -113,70 +213,28 @@ func checkVersion(cReg registry.ClusterRegistry) (string, bool) { return "", true } -var ( - globalFlags = []cli.Flag{ - cli.BoolFlag{Name: "debug", Usage: "Print out more debug information to stderr"}, - cli.StringFlag{Name: "driver", Value: clientDriverAPI, Usage: fmt.Sprintf("Adapter used to execute fleetctl commands. Options include %q and %q.", clientDriverAPI, clientDriverEtcd)}, - cli.StringFlag{Name: "endpoint", Value: defaultEndpoint, Usage: fmt.Sprintf("Location of the fleet API if --driver=%s. Alternatively, if --driver=%s, location of the etcd API.", clientDriverAPI, clientDriverEtcd)}, - cli.StringFlag{Name: "etcd-key-prefix", Value: registry.DefaultKeyPrefix, Usage: "Keyspace for fleet data in etcd (development use only!)"}, - cli.StringFlag{Name: "key-file", Value: "", Usage: "Location of TLS key file used to secure communication with the fleet API or etcd"}, - cli.StringFlag{Name: "cert-file", Value: "", Usage: "Location of TLS cert file used to secure communication with the fleet API or etcd"}, - cli.StringFlag{Name: "ca-file", Value: "", Usage: "Location of TLS CA file used to secure communication with the fleet API or etcd"}, - cli.StringFlag{Name: "known-hosts-file", Value: ssh.DefaultKnownHostsFile, Usage: "File used to store remote machine fingerprints. Ignored if strict host key checking is disabled."}, - cli.BoolTFlag{Name: "strict-host-key-checking", Usage: "Verify host keys presented by remote machines before initiating SSH connections."}, - cli.DurationFlag{Name: "ssh-timeout", Value: 10 * time.Second, Usage: "Amount of time in seconds to allow for SSH connection initialization before failing."}, - cli.StringFlag{Name: "tunnel", Value: "", Usage: "Establish an SSH tunnel through the provided address for communication with fleet and etcd."}, - cli.DurationFlag{Name: "request-timeout", Value: 3 * time.Second, Usage: "Amount of time in seconds to allow a single request before considering it failed."}, - cli.StringFlag{Name: "ssh-username", Value: "core", Usage: "Username to use when connecting to CoreOS instance."}, - // deprecated flags - cli.BoolTFlag{Name: "experimental-api", Usage: "DEPRECATED"}, - cli.StringFlag{Name: "etcd-keyfile", Value: "", Usage: "DEPRECATED"}, - cli.StringFlag{Name: "etcd-certfile", Value: "", Usage: "DEPRECATED"}, - cli.StringFlag{Name: "etcd-cafile", Value: "", Usage: "DEPRECATED"}, - } - globalCommands = []cli.Command{ - NewCatCommand(), - NewDestroyCommand(), - NewFDForwardCommand(), - NewJournalCommand(), - NewListMachinesCommand(), - NewListUnitFilesCommand(), - NewListUnitsCommand(), - NewLoadUnitsCommand(), - NewSSHCommend(), - NewStartCommand(), - NewStatusCommand(), - NewStopUnitCommand(), - NewSubmitUnitCommand(), - NewUnloadUnitCommand(), - NewVerifyCommand(), - } -) - -func createApp() *cli.App { - app := cli.NewApp() - app.Name = "fleetctl" - app.Version = version.Version - app.Usage = "command-line interface to fleet." - - app.Flags = globalFlags - app.Commands = globalCommands - - return app -} - func main() { - app := createApp() + if globalFlags.Debug { + log.EnableDebug() + } // call this as early as possible to ensure we always have timestamps // on fleetctl logs log.EnableTimestamps() + if len(os.Args) == 1 { + cmdFleet.Help() + os.Exit(0) + } + + if os.Args[1] == "--version" || os.Args[1] == "-v" { + runVersion(cmdVersion, nil) + os.Exit(0) + } + // determine currentCommand. We only need this for --replace and its // functional tests, so just handle those for now in the switch... // "The rest" doesn't care about "currentCommand" - //stderr("%d command line arguments", len(os.Args)) - //stderr("%s", os.Args) if len(os.Args) > 1 { for i := 1; i < len(os.Args); i++ { switch os.Args[i] { @@ -190,22 +248,31 @@ func main() { continue } } - // stderr("First: %s", os.Args[1]) } - app.Run(os.Args) -} -func makeActionWrapper(action func(context *cli.Context, cAPI client.API) int) func(context *cli.Context) { - return func(c *cli.Context) { - if c.Bool("sign") { - stderr("WARNING: The signed/verified units feature is DEPRECATED and cannot be used.") - os.Exit(2) - } - cAPI := getClientAPI(c) - if ret := action(c, cAPI); ret != 0 { - os.Exit(ret) + if sharedFlags.Sign { + stderr("WARNING: The signed/verified units feature is DEPRECATED and cannot be used.") + os.Exit(2) + } + + // if --driver is not set, but --endpoint looks like an etcd + // server, set the driver to etcd + if globalFlags.Endpoint != "" && globalFlags.ClientDriver == "" { + if u, err := url.Parse(strings.Split(globalFlags.Endpoint, ",")[0]); err == nil { + if _, port, err := net.SplitHostPort(u.Host); err == nil && (port == "4001" || port == "2379") { + log.Debugf("Defaulting to --driver=%s as --endpoint appears to be etcd", clientDriverEtcd) + globalFlags.ClientDriver = clientDriverEtcd + } } } + + cmdFleet.SetUsageFunc(usageFunc) + cmdFleet.SetHelpTemplate(`{{.UsageString}}`) + + if err := cmdFleet.Execute(); err != nil { + stderr("cannot execute cmdFleet: %v", err) + } + os.Exit(cmdExitCode) } // getFlagsFromEnv parses all registered flags in the given flagset, @@ -230,9 +297,9 @@ func getFlagsFromEnv(prefix string, fs *flag.FlagSet) { }) } -func getClientAPI(c *cli.Context) client.API { +func getClientAPI(cCmd *cobra.Command) client.API { var err error - cAPI, err = getClient(c) + cAPI, err = getClient(cCmd) if err != nil { stderr("Unable to initialize client: %v", err) os.Exit(1) @@ -241,44 +308,35 @@ func getClientAPI(c *cli.Context) client.API { } // getClient initializes a client of fleet based on CLI flags -func getClient(c *cli.Context) (client.API, error) { - driverFlag := c.GlobalString("driver") - // if --driver is not set, but --endpoint looks like an etcd - // server, set the driver to etcd - if c.GlobalIsSet("endpoint") && !c.GlobalIsSet("driver") { - if u, err := url.Parse(strings.Split(c.GlobalString("endpoint"), ",")[0]); err == nil { - if _, port, err := net.SplitHostPort(u.Host); err == nil && (port == "4001" || port == "2379") { - log.Debugf("Defaulting to --driver=%s as --endpoint appears to be etcd", clientDriverEtcd) - driverFlag = clientDriverEtcd - } - } - } - - endpointFlag := c.GlobalString("endpoint") +func getClient(cCmd *cobra.Command) (client.API, error) { // The user explicitly set --experimental-api=false, so it trumps the // --driver flag. This behavior exists for backwards-compatibilty. - if !c.GlobalBool("experimental-api") { + experimentalAPI, _ := cmdFleet.PersistentFlags().GetBool("experimental-api") + endPoint, _ := cmdFleet.PersistentFlags().GetString("endpoint") + clientDriver, _ := cmdFleet.PersistentFlags().GetString("driver") + if !experimentalAPI { // Additionally, if the user set --experimental-api=false and did // not change the value of --endpoint, they likely want to use the // old default value. - if endpointFlag == defaultEndpoint { - endpointFlag = "http://127.0.0.1:2379,http://127.0.0.1:4001" + if endPoint == defaultEndpoint { + endPoint = "http://127.0.0.1:2379,http://127.0.0.1:4001" } - return getRegistryClient(c) + return getRegistryClient(cCmd) } - switch driverFlag { + switch clientDriver { case clientDriverAPI: - return getHTTPClient(c, endpointFlag) + return getHTTPClient(cCmd) case clientDriverEtcd: - return getRegistryClient(c) + return getRegistryClient(cCmd) } - return nil, fmt.Errorf("unrecognized driver %q", driverFlag) + return nil, fmt.Errorf("unrecognized driver %q", clientDriver) } -func getHTTPClient(c *cli.Context, endpointFlag string) (client.API, error) { - endpoints := strings.Split(endpointFlag, ",") +func getHTTPClient(cCmd *cobra.Command) (client.API, error) { + endPoint, _ := cmdFleet.PersistentFlags().GetString("endpoint") + endpoints := strings.Split(endPoint, ",") if len(endpoints) > 1 { log.Warningf("multiple endpoints provided but only the first (%s) is used", endpoints[0]) } @@ -292,14 +350,15 @@ func getHTTPClient(c *cli.Context, endpointFlag string) (client.API, error) { return nil, errors.New("URL scheme undefined") } - tun := getTunnelFlag(c) + tun := getTunnelFlag(cCmd) tunneling := tun != "" dialUnix := ep.Scheme == "unix" || ep.Scheme == "file" + SSHUserName, _ := cmdFleet.PersistentFlags().GetString("ssh-username") tunnelFunc := net.Dial if tunneling { - sshClient, err := ssh.NewSSHClient(c.GlobalString("ssh-username"), tun, getChecker(c), true, getSSHTimeoutFlag(c)) + sshClient, err := ssh.NewSSHClient(SSHUserName, tun, getChecker(cCmd), true, getSSHTimeoutFlag(cCmd)) if err != nil { return nil, fmt.Errorf("failed initializing SSH client: %v", err) } @@ -346,7 +405,10 @@ func getHTTPClient(c *cli.Context, endpointFlag string) (client.API, error) { ep.Host = "domain-sock" } - tlsConfig, err := pkg.ReadTLSConfigFiles(c.GlobalString("ca-file"), c.GlobalString("cert-file"), c.GlobalString("key-file")) + CAFile, _ := cmdFleet.PersistentFlags().GetString("ca-file") + CertFile, _ := cmdFleet.PersistentFlags().GetString("cert-file") + KeyFile, _ := cmdFleet.PersistentFlags().GetString("key-file") + tlsConfig, err := pkg.ReadTLSConfigFiles(CAFile, CertFile, KeyFile) if err != nil { return nil, err } @@ -365,11 +427,12 @@ func getHTTPClient(c *cli.Context, endpointFlag string) (client.API, error) { return client.NewHTTPClient(&hc, *ep) } -func getRegistryClient(c *cli.Context) (client.API, error) { +func getRegistryClient(cCmd *cobra.Command) (client.API, error) { var dial func(string, string) (net.Conn, error) - tun := getTunnelFlag(c) + SSHUserName, _ := cmdFleet.PersistentFlags().GetString("ssh-username") + tun := getTunnelFlag(cCmd) if tun != "" { - sshClient, err := ssh.NewSSHClient(c.GlobalString("ssh-username"), tun, getChecker(c), false, getSSHTimeoutFlag(c)) + sshClient, err := ssh.NewSSHClient(SSHUserName, tun, getChecker(cCmd), false, getSSHTimeoutFlag(cCmd)) if err != nil { return nil, fmt.Errorf("failed initializing SSH client: %v", err) } @@ -383,7 +446,10 @@ func getRegistryClient(c *cli.Context) (client.API, error) { } } - tlsConfig, err := pkg.ReadTLSConfigFiles(c.GlobalString("ca-file"), c.GlobalString("cert-file"), c.GlobalString("key-file")) + CAFile, _ := cmdFleet.PersistentFlags().GetString("ca-file") + CertFile, _ := cmdFleet.PersistentFlags().GetString("cert-file") + KeyFile, _ := cmdFleet.PersistentFlags().GetString("key-file") + tlsConfig, err := pkg.ReadTLSConfigFiles(CAFile, CertFile, KeyFile) if err != nil { return nil, err } @@ -393,10 +459,11 @@ func getRegistryClient(c *cli.Context) (client.API, error) { TLSClientConfig: tlsConfig, } + endPoint, _ := cmdFleet.PersistentFlags().GetString("endpoint") eCfg := etcd.Config{ - Endpoints: strings.Split(c.GlobalString("endpoint"), ","), + Endpoints: strings.Split(endPoint, ","), Transport: trans, - HeaderTimeoutPerRequest: getRequestTimeoutFlag(), + HeaderTimeoutPerRequest: getRequestTimeoutFlag(cCmd), } eClient, err := etcd.New(eCfg) @@ -404,8 +471,9 @@ func getRegistryClient(c *cli.Context) (client.API, error) { return nil, err } + etcdKeyPrefix, _ := cmdFleet.PersistentFlags().GetString("etcd-key-prefix") kAPI := etcd.NewKeysAPI(eClient) - reg := registry.NewEtcdRegistry(kAPI, c.GlobalString("etcd-key-prefix")) + reg := registry.NewEtcdRegistry(kAPI, etcdKeyPrefix) if msg, ok := checkVersion(reg); !ok { stderr(msg) @@ -415,12 +483,14 @@ func getRegistryClient(c *cli.Context) (client.API, error) { } // getChecker creates and returns a HostKeyChecker, or nil if any error is encountered -func getChecker(c *cli.Context) *ssh.HostKeyChecker { - if !c.GlobalBool("strict-host-key-checking") { +func getChecker(cCmd *cobra.Command) *ssh.HostKeyChecker { + strictHostKeyChecking, _ := cmdFleet.PersistentFlags().GetBool("strict-host-key-checking") + if !strictHostKeyChecking { return nil } - keyFile := ssh.NewHostKeyFile(c.GlobalString("known-hosts-file")) + knownHostsFile, _ := cmdFleet.PersistentFlags().GetString("known-hosts-file") + keyFile := ssh.NewHostKeyFile(knownHostsFile) return ssh.NewHostKeyChecker(keyFile) } @@ -431,7 +501,7 @@ func getChecker(c *cli.Context) *ssh.HostKeyChecker { // tries to get the template configuration either from the registry or // the local disk. // It returns a UnitFile configuration or nil; and any error ecountered -func getUnitFile(file string, c *cli.Context) (*unit.UnitFile, error) { +func getUnitFile(cCmd *cobra.Command, file string) (*unit.UnitFile, error) { var uf *unit.UnitFile name := unitNameMangle(file) @@ -459,7 +529,7 @@ func getUnitFile(file string, c *cli.Context) (*unit.UnitFile, error) { // If we found a template unit, later we create a // near-identical instance unit in the Registry - same // unit file as the template, but different name - uf, err = getUnitFileFromTemplate(info, file, c) + uf, err = getUnitFileFromTemplate(cCmd, info, file) if err != nil { return nil, fmt.Errorf("failed getting Unit(%s) from template: %v", file, err) } @@ -487,7 +557,7 @@ func getUnitFromFile(file string) (*unit.UnitFile, error) { // is either in the registry or on the file system // It takes two arguments, the template information and the unit file name // It returns the Unit or nil; and any error encountered -func getUnitFileFromTemplate(uni *unit.UnitNameInfo, fileName string, c *cli.Context) (*unit.UnitFile, error) { +func getUnitFileFromTemplate(cCmd *cobra.Command, uni *unit.UnitNameInfo, fileName string) (*unit.UnitFile, error) { var uf *unit.UnitFile tmpl, err := cAPI.Unit(uni.Template) @@ -496,7 +566,7 @@ func getUnitFileFromTemplate(uni *unit.UnitNameInfo, fileName string, c *cli.Con } if tmpl != nil { - isLocalUnitDifferent(fileName, tmpl, false, c) + isLocalUnitDifferent(cCmd, fileName, tmpl, false) uf = schema.MapSchemaUnitOptionsToUnitFile(tmpl.Options) log.Debugf("Template Unit(%s) found in registry", uni.Template) } else { @@ -516,20 +586,22 @@ func getUnitFileFromTemplate(uni *unit.UnitNameInfo, fileName string, c *cli.Con return uf, nil } -func getTunnelFlag(c *cli.Context) string { - tun := c.GlobalString("tunnel") +func getTunnelFlag(cCmd *cobra.Command) string { + tun, _ := cmdFleet.PersistentFlags().GetString("tunnel") if tun != "" && !strings.Contains(tun, ":") { tun += ":22" } return tun } -func getSSHTimeoutFlag(c *cli.Context) time.Duration { - return c.GlobalDuration("ssh-timeout") +func getSSHTimeoutFlag(cCmd *cobra.Command) time.Duration { + sshTimeout, _ := cmdFleet.PersistentFlags().GetFloat64("ssh-timeout") + return time.Duration(sshTimeout*1000) * time.Millisecond } -func getRequestTimeoutFlag(c *cli.Context) time.Duration { - return c.GlobalDuration("request-timeout") +func getRequestTimeoutFlag(cCmd *cobra.Command) time.Duration { + reqTimeout, _ := cmdFleet.PersistentFlags().GetFloat64("request-timeout") + return time.Duration(reqTimeout*1000) * time.Millisecond } func machineIDLegend(ms machine.MachineState, full bool) string { @@ -648,7 +720,7 @@ func checkReplaceUnitState(unit *schema.Unit) (int, error) { // It takes a unit file path as a parameter. // It returns 0 on success and if the unit should be created, 1 if the // unit should not be created; and any error encountered. -func checkUnitCreation(arg string, c *cli.Context) (int, error) { +func checkUnitCreation(cCmd *cobra.Command, arg string) (int, error) { name := unitNameMangle(arg) // First, check if there already exists a Unit by the given name in the Registry @@ -657,21 +729,22 @@ func checkUnitCreation(arg string, c *cli.Context) (int, error) { return 1, fmt.Errorf("error retrieving Unit(%s) from Registry: %v", name, err) } + replace, _ := cCmd.Flags().GetBool("replace") + // check if the unit is running if unit == nil { - if c.Bool("replace") { + if replace { log.Debugf("Unit(%s) was not found in Registry", name) } // Create a new unit return 0, nil } - // if sharedFlags.Replace is not set then we warn in case - // the units differ - different, err := isLocalUnitDifferent(arg, unit, false, c) + // if replace is not set then we warn in case the units differ + different, err := isLocalUnitDifferent(cCmd, arg, unit, false) - // if sharedFlags.Replace is set then we fail for errors - if c.Bool("replace") { + // if replace is set then we fail for errors + if replace { if err != nil { return 1, err } else if different { @@ -696,15 +769,15 @@ func checkUnitCreation(arg string, c *cli.Context) (int, error) { // Any error encountered during these steps is returned immediately (i.e. // subsequent Jobs are not acted on). An error is also returned if none of the // above conditions match a given Job. -func lazyCreateUnits(c *cli.Context) error { - args := c.Args() +func lazyCreateUnits(cCmd *cobra.Command, args []string) error { errchan := make(chan error) + blockAttempts, _ := cCmd.Flags().GetInt("block-attempts") var wg sync.WaitGroup for _, arg := range args { arg = maybeAppendDefaultUnitType(arg) name := unitNameMangle(arg) - ret, err := checkUnitCreation(arg, c) + ret, err := checkUnitCreation(cCmd, arg) if err != nil { return err } else if ret != 0 { @@ -714,7 +787,7 @@ func lazyCreateUnits(c *cli.Context) error { // Assume that the name references a local unit file on // disk or if it is an instance unit and if so get its // corresponding unit - uf, err := getUnitFile(arg, c) + uf, err := getUnitFile(cCmd, arg) if err != nil { return err } @@ -725,7 +798,7 @@ func lazyCreateUnits(c *cli.Context) error { } wg.Add(1) - go checkUnitState(name, job.JobStateInactive, c.Int("block-attempts"), os.Stdout, &wg, errchan) + go checkUnitState(name, job.JobStateInactive, blockAttempts, os.Stdout, &wg, errchan) } go func() { @@ -777,11 +850,13 @@ func matchLocalFileAndUnit(file string, su *schema.Unit) (bool, error) { // happen. // Returns true if the local Unit on file system is different from the // one provided, false otherwise; and any error encountered. -func isLocalUnitDifferent(file string, su *schema.Unit, fatal bool, c *cli.Context) (bool, error) { +func isLocalUnitDifferent(cCmd *cobra.Command, file string, su *schema.Unit, fatal bool) (bool, error) { + replace, _ := cCmd.Flags().GetBool("replace") + result, err := matchLocalFileAndUnit(file, su) if err == nil { // Warn in case unit differs from local file - if result == false && !c.Bool("replace") { + if result == false && !replace { stderr("WARNING: Unit %s in registry differs from local unit file %s. Add --replace to override.", su.Name, file) } return !result, nil @@ -800,7 +875,7 @@ func isLocalUnitDifferent(file string, su *schema.Unit, fatal bool, c *cli.Conte result, err = matchLocalFileAndUnit(templFile, su) if err == nil { // Warn in case unit differs from local template unit file - if result == false && !c.Bool("replace") { + if result == false && !replace { stderr("WARNING: Unit %s in registry differs from local template unit file %s. Add --replace to override.", su.Name, file) } return !result, nil @@ -857,15 +932,15 @@ func setTargetStateOfUnits(units []string, state job.JobState) ([]*schema.Unit, // It returns a negative value which means do not block, if zero is // returned then it means try forever, and if a positive value is // returned then try up to that value -func getBlockAttempts(c *cli.Context) int { +func getBlockAttempts(cCmd *cobra.Command) int { // By default we wait forever var attempts int = 0 - if c.Int("block-attempts") > 0 { - attempts = c.Int("block-attempts") + if sharedFlags.BlockAttempts > 0 { + attempts = sharedFlags.BlockAttempts } - if c.Bool("no-block") { + if sharedFlags.NoBlock { attempts = -1 } @@ -1035,3 +1110,18 @@ func suToGlobal(su schema.Unit) bool { } return u.IsGlobal() } + +// runWrapper returns a func(cCmd *cobra.Command, args []string) that +// internally will add command function return code, to be able to used for +// cobra.Command.Run(). +// Note that cAPI must be set before calling cf(), to be able to distinguish +// different contexts, i.e. a normal cmdline (cAPI) vs. unit test (fakeAPI). +// So the setting cAPI in runWrapper() has nothing to do with the unit test +// context. In case of unit tests, cAPI will be set to fakeAPI before calling +// each run() function, which won't reach runWrapper at all. +func runWrapper(cf func(cCmd *cobra.Command, args []string) (exit int)) func(cCmd *cobra.Command, args []string) { + return func(cCmd *cobra.Command, args []string) { + cAPI = getClientAPI(cCmd) + cmdExitCode = cf(cCmd, args) + } +} diff --git a/fleetctl/help.go b/fleetctl/help.go new file mode 100644 index 000000000..204ab33b0 --- /dev/null +++ b/fleetctl/help.go @@ -0,0 +1,129 @@ +// Copyright 2016 CoreOS, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package main + +import ( + "io" + "os" + "strings" + "text/tabwriter" + "text/template" + + "github.com/coreos/fleet/version" + "github.com/spf13/cobra" +) + +var ( + commandUsageTemplate *template.Template + templFuncs = template.FuncMap{ + "descToLines": func(s string) []string { + // trim leading/trailing whitespace and split into slice of lines + return strings.Split(strings.Trim(s, "\n\t "), "\n") + }, + "cmdName": func(cCmd *cobra.Command, startCmd *cobra.Command) string { + parts := []string{cCmd.Name()} + for cCmd.HasParent() && cCmd.Parent().Name() != startCmd.Name() { + cCmd = cCmd.Parent() + parts = append([]string{cCmd.Name()}, parts...) + } + return strings.Join(parts, " ") + }, + } +) + +func init() { + commandUsage := ` +{{ $cmd := .Cmd }}\ +{{ $cmdname := cmdName .Cmd .Cmd.Root }}\ +NAME: +{{ if not .Cmd.HasParent }}\ +{{printf "\t%s - %s" .Cmd.Name .Cmd.Short}} +{{else}}\ +{{printf "\t%s - %s" $cmdname .Cmd.Short}} +{{end}}\ + +USAGE: +{{printf "\t%s" .Cmd.UseLine}} +{{ if not .Cmd.HasParent }}\ + +VERSION: +{{printf "\t%s" .Version}} +{{end}}\ +{{if .Cmd.HasSubCommands}}\ + +COMMANDS: +{{range .SubCommands}}\ +{{ $cmdname := cmdName . $cmd }}\ +{{ if .Runnable }}\ +{{printf "\t%s\t%s" $cmdname .Short}} +{{end}}\ +{{end}}\ +{{end}}\ +{{ if .Cmd.Long }}\ + +DESCRIPTION: +{{range $line := descToLines .Cmd.Long}}{{printf "\t%s" $line}} +{{end}}\ +{{end}}\ +{{if .Cmd.HasLocalFlags}}\ + +OPTIONS: +{{.LocalFlags}}\ +{{end}}\ +{{if .Cmd.HasInheritedFlags}}\ + +GLOBAL OPTIONS: +{{.GlobalFlags}}\ +{{end}} +`[1:] + + commandUsageTemplate = template.Must(template.New("command_usage").Funcs(templFuncs).Parse(strings.Replace(commandUsage, "\\\n", "", -1))) +} + +func getSubCommands(cCmd *cobra.Command) []*cobra.Command { + var subCommands []*cobra.Command + for _, subCmd := range cCmd.Commands() { + subCommands = append(subCommands, subCmd) + subCommands = append(subCommands, getSubCommands(subCmd)...) + } + return subCommands +} + +func usageFunc(cCmd *cobra.Command) error { + subCommands := getSubCommands(cCmd) + tabOut := getTabOutWithWriter(os.Stdout) + commandUsageTemplate.Execute(tabOut, struct { + Cmd *cobra.Command + LocalFlags string + GlobalFlags string + SubCommands []*cobra.Command + Version string + }{ + cCmd, + cCmd.LocalFlags().FlagUsages(), + cCmd.InheritedFlags().FlagUsages(), + subCommands, + version.Version, + }) + tabOut.Flush() + return nil +} + +func getTabOutWithWriter(writer io.Writer) *tabwriter.Writer { + aTabOut := new(tabwriter.Writer) + aTabOut.Init(writer, 0, 8, 1, '\t', 0) + + return aTabOut +} diff --git a/fleetctl/journal.go b/fleetctl/journal.go index b3fcca522..d48e24620 100644 --- a/fleetctl/journal.go +++ b/fleetctl/journal.go @@ -17,39 +17,45 @@ package main import ( "strconv" - "github.com/codegangsta/cli" + "github.com/spf13/cobra" - "github.com/coreos/fleet/client" "github.com/coreos/fleet/job" ) -func NewJournalCommand() cli.Command { - return cli.Command{ - Name: "journal", - Usage: "Print the journal of a unit in the cluster to stdout", - ArgsUsage: "[--lines=N] [--ssh-port=N] [-f|--follow] [--output=STRING] ", - Action: makeActionWrapper(runJournal), - Description: `Outputs the journal of a unit by connecting to the machine that the unit occupies. +var ( + flagLines int + flagFollow bool + flagSudo bool + flagOutput string +) + +var cmdJournal = &cobra.Command{ + Use: "journal [--lines=N] [--ssh-port=N] [-f|--follow] [--output=STRING] ", + Short: "Print the journal of a unit in the cluster to stdout", + Long: `Outputs the journal of a unit by connecting to the machine that the unit occupies. Read the last 10 lines: - fleetctl journal foo.service +fleetctl journal foo.service Read the last 100 lines: - fleetctl journal --lines 100 foo.service +fleetctl journal --lines 100 foo.service This command does not work with global units.`, - Flags: []cli.Flag{ - cli.IntFlag{Name: "lines", Value: 10, Usage: "Number of recent log lines to return"}, - cli.BoolFlag{Name: "follow, f", Usage: "Continuously print new entries as they are appended to the journal."}, - cli.IntFlag{Name: "ssh-port", Value: 22, Usage: "Connect to remote hosts over SSH using this TCP port"}, - cli.BoolFlag{Name: "sudo", Usage: "Execute journal command with sudo"}, - cli.StringFlag{Name: "output", Value: "short", Usage: "Output mode. This will be passed unaltered to journalctl on the remote host, and hence supports the same modes as that command."}, - }, - } + Run: runWrapper(runJournal), +} + +func init() { + cmdFleet.AddCommand(cmdJournal) + + cmdJournal.Flags().IntVar(&flagLines, "lines", 10, "Number of recent log lines to return") + cmdJournal.Flags().BoolVar(&flagFollow, "follow", false, "Continuously print new entries as they are appended to the journal.") + cmdJournal.Flags().BoolVar(&flagFollow, "f", false, "Shorthand for --follow") + cmdJournal.Flags().IntVar(&sharedFlags.SSHPort, "ssh-port", 22, "Connect to remote hosts over SSH using this TCP port") + cmdJournal.Flags().BoolVar(&flagSudo, "sudo", false, "Execute journal command with sudo") + cmdJournal.Flags().StringVar(&flagOutput, "output", "short", "Output mode. This will be passed unaltered to journalctl on the remote host, and hence supports the same modes as that command.") } -func runJournal(c *cli.Context, cAPI client.API) (exit int) { - args := c.Args() +func runJournal(cCmd *cobra.Command, args []string) (exit int) { if len(args) != 1 { stderr("One unit file must be provided.") return 1 @@ -71,15 +77,17 @@ func runJournal(c *cli.Context, cAPI client.API) (exit int) { return 1 } - cmd := []string{"journalctl", "--unit", name, "--no-pager", "-n", strconv.Itoa(c.Int("lines")), "--output", c.String("output")} + lines, _ := cCmd.Flags().GetInt("lines") + cmd := []string{"journalctl", "--unit", name, "--no-pager", "-n", strconv.Itoa(lines), "--output", flagOutput} - if c.Bool("sudo") { + if flagSudo { cmd = append([]string{"sudo"}, cmd...) } - if c.Bool("follow") { + if flagFollow { cmd = append(cmd, "-f") } - return runCommand(c, u.MachineID, cmd[0], cmd[1:]...) + exit = runCommand(cCmd, u.MachineID, cmd[0], cmd[1:]...) + return } diff --git a/fleetctl/list_machines.go b/fleetctl/list_machines.go index 8b83bf296..2d8ebbded 100644 --- a/fleetctl/list_machines.go +++ b/fleetctl/list_machines.go @@ -19,37 +19,18 @@ import ( "sort" "strings" - "github.com/codegangsta/cli" + "github.com/spf13/cobra" - "github.com/coreos/fleet/client" "github.com/coreos/fleet/machine" ) -func NewListMachinesCommand() cli.Command { - return cli.Command{ - Name: "list-machines", - Usage: "Enumerate the current hosts in the cluster", - Description: `Lists all active machines within the cluster. Previously active machines will not appear in this list. - -For easily parsable output, you can remove the column headers: - fleetctl list-machines --no-legend - -Output the list without truncation: - fleetctl list-machines --full`, - ArgsUsage: "[-l|--full] [--no-legend]", - Action: makeActionWrapper(runListMachines), - Flags: []cli.Flag{ - cli.BoolFlag{Name: "full, l", Usage: "Output the list without truncation"}, - cli.BoolFlag{Name: "no-legend", Usage: "Remove the column headers"}, - cli.StringFlag{Name: "fields", Value: defaultListMachinesFields, Usage: fmt.Sprintf("Columns to print for each Machine. Valid fields are %s", defaultListMachinesFields)}, - }, - } -} +const ( + defaultListMachinesFields = "machine,ip,metadata" +) var ( - //listMachinesFieldsFlag string - // Update defaultListMachinesFields if you add a new field here - listMachinesFields = map[string]machineToField{ + listMachinesFieldsFlag string + listMachinesFields = map[string]machineToField{ "machine": func(ms *machine.MachineState, full bool) string { return machineIDLegend(*ms, full) }, @@ -68,14 +49,31 @@ var ( } ) -const ( - defaultListMachinesFields = "machine,ip,metadata" -) - type machineToField func(ms *machine.MachineState, full bool) string -func runListMachines(c *cli.Context, cAPI client.API) (exit int) { - listMachinesFieldsFlag := c.String("fields") +var cmdListMachines = &cobra.Command{ + Use: "list-machines [-l|--full] [--no-legend]", + Short: "Enumerate the current hosts in the cluster", + Long: `Lists all active machines within the cluster. Previously active machines will not appear in this list. + +For easily parsable output, you can remove the column headers: +fleetctl list-machines --no-legend + +Output the list without truncation: +fleetctl list-machines --full`, + Run: runWrapper(runListMachines), +} + +func init() { + cmdFleet.AddCommand(cmdListMachines) + + cmdListMachines.Flags().BoolVar(&sharedFlags.Full, "full", false, "Do not ellipsize fields on output") + cmdListMachines.Flags().BoolVar(&sharedFlags.Full, "l", false, "Shorthand for --full") + cmdListMachines.Flags().BoolVar(&sharedFlags.NoLegend, "no-legend", false, "Do not print a legend (column headers)") + cmdListMachines.Flags().StringVar(&listMachinesFieldsFlag, "fields", defaultListMachinesFields, fmt.Sprintf("Columns to print for each Machine. Valid fields are %q", strings.Join(machineToFieldKeys(listMachinesFields), ","))) +} + +func runListMachines(cCmd *cobra.Command, args []string) (exit int) { if listMachinesFieldsFlag == "" { stderr("Must define output format") return 1 @@ -95,22 +93,24 @@ func runListMachines(c *cli.Context, cAPI client.API) (exit int) { return 1 } - if !c.Bool("no-legend") { + noLegend, _ := cCmd.Flags().GetBool("no-legend") + if !noLegend { fmt.Fprintln(out, strings.ToUpper(strings.Join(cols, "\t"))) } + full, _ := cCmd.Flags().GetBool("full") for _, ms := range machines { ms := ms var f []string - for _, col := range cols { - f = append(f, listMachinesFields[col](&ms, c.Bool("full"))) + for _, c := range cols { + f = append(f, listMachinesFields[c](&ms, full)) } fmt.Fprintln(out, strings.Join(f, "\t")) } out.Flush() - return + return 0 } func formatMetadata(metadata map[string]string) string { diff --git a/fleetctl/list_unit_files.go b/fleetctl/list_unit_files.go index 1c9d2bc03..b23af4286 100644 --- a/fleetctl/list_unit_files.go +++ b/fleetctl/list_unit_files.go @@ -20,9 +20,8 @@ import ( "strconv" "strings" - "github.com/codegangsta/cli" + "github.com/spf13/cobra" - "github.com/coreos/fleet/client" "github.com/coreos/fleet/machine" "github.com/coreos/fleet/schema" ) @@ -46,23 +45,9 @@ func mapTargetField(u schema.Unit, full bool) string { return machineFullLegend(*ms, full) } -func NewListUnitFilesCommand() cli.Command { - return cli.Command{ - Name: "list-unit-files", - Usage: "List the units that exist in the cluster.", - ArgsUsage: "[--fields]", - Description: "Lists all unit files that exist in the cluster (whether or not they are loaded onto a machine)", - Action: makeActionWrapper(runListUnitFiles), - Flags: []cli.Flag{ - cli.BoolFlag{Name: "full", Usage: "Do not ellipsize fields on output"}, - cli.BoolFlag{Name: "no-legend", Usage: "Do not print a legend (column headers)"}, - cli.StringFlag{Name: "fields", Value: defaultListUnitFilesFields, Usage: fmt.Sprintf("Columns to print for each Unit file. Valid fields are %q", strings.Join(unitToFieldKeys(listUnitFilesFields), ","))}, - }, - } -} - var ( - listUnitFilesFields = map[string]unitToField{ + listUnitFilesFieldsFlag string + listUnitFilesFields = map[string]unitToField{ "unit": func(u schema.Unit, full bool) string { return u.Name }, @@ -103,8 +88,22 @@ var ( type unitToField func(u schema.Unit, full bool) string -func runListUnitFiles(c *cli.Context, cAPI client.API) (exit int) { - listUnitFilesFieldsFlag := c.String("fields") +var cmdListUnitFiles = &cobra.Command{ + Use: "list-unit-files [--fields]", + Short: "List the units that exist in the cluster.", + Long: `Lists all unit files that exist in the cluster (whether or not they are loaded onto a machine).`, + Run: runWrapper(runListUnitFiles), +} + +func init() { + cmdFleet.AddCommand(cmdListUnitFiles) + + cmdListUnitFiles.Flags().BoolVar(&sharedFlags.Full, "full", false, "Do not ellipsize fields on output") + cmdListUnitFiles.Flags().BoolVar(&sharedFlags.NoLegend, "no-legend", false, "Do not print a legend (column headers)") + cmdListUnitFiles.Flags().StringVar(&listUnitFilesFieldsFlag, "fields", defaultListUnitFilesFields, fmt.Sprintf("Columns to print for each Unit file. Valid fields are %q", strings.Join(unitToFieldKeys(listUnitFilesFields), ","))) +} + +func runListUnitFiles(cCmd *cobra.Command, args []string) (exit int) { if listUnitFilesFieldsFlag == "" { stderr("Must define output format") return 1 @@ -127,21 +126,22 @@ func runListUnitFiles(c *cli.Context, cAPI client.API) (exit int) { return 1 } - if !c.Bool("no-legend") { + noLegend, _ := cCmd.Flags().GetBool("no-legend") + if !noLegend { fmt.Fprintln(out, strings.ToUpper(strings.Join(cols, "\t"))) } + full, _ := cCmd.Flags().GetBool("full") for _, u := range units { var f []string - for _, col := range cols { - f = append(f, listUnitFilesFields[col](*u, c.Bool("full"))) + for _, c := range cols { + f = append(f, listUnitFilesFields[c](*u, full)) } fmt.Fprintln(out, strings.Join(f, "\t")) } out.Flush() - - return + return 0 } func unitToFieldKeys(m map[string]unitToField) (keys []string) { diff --git a/fleetctl/list_units.go b/fleetctl/list_units.go index d82b85c60..7a299feb1 100644 --- a/fleetctl/list_units.go +++ b/fleetctl/list_units.go @@ -19,9 +19,8 @@ import ( "sort" "strings" - "github.com/codegangsta/cli" + "github.com/spf13/cobra" - "github.com/coreos/fleet/client" "github.com/coreos/fleet/machine" "github.com/coreos/fleet/schema" ) @@ -30,32 +29,9 @@ const ( defaultListUnitsFields = "unit,machine,active,sub" ) -func NewListUnitsCommand() cli.Command { - return cli.Command{ - Name: "list-units", - Usage: "List the current state of units in the cluster", - ArgsUsage: "[--no-legend] [-l|--full] [--fields]", - Description: `Lists the state of all units in the cluster loaded onto a machine. - -For easily parsable output, you can remove the column headers: - fleetctl list-units --no-legend - -Output the list without ellipses: - fleetctl list-units --full - -Or, choose the columns to display: - fleetctl list-units --fields=unit,machine`, - Action: makeActionWrapper(runListUnits), - Flags: []cli.Flag{ - cli.BoolFlag{Name: "full, l", Usage: "Do not ellipsize fields on output"}, - cli.BoolFlag{Name: "no-legend", Usage: "Do not print a legend (column headers)"}, - cli.StringFlag{Name: "fields", Value: defaultListUnitsFields, Usage: fmt.Sprintf("Columns to print for each Unit. Valid fields are %q", strings.Join(usToFieldKeys(listUnitsFields), ","))}, - }, - } -} - var ( - listUnitsFields = map[string]usToField{ + listUnitsFieldsFlag string + listUnitsFields = map[string]usToField{ "unit": func(us *schema.UnitState, full bool) string { if us == nil { return "-" @@ -104,8 +80,32 @@ var ( type usToField func(us *schema.UnitState, full bool) string -func runListUnits(c *cli.Context, cAPI client.API) (exit int) { - listUnitsFieldsFlag := c.String("fields") +var cmdListUnits = &cobra.Command{ + Use: "list-units [--no-legend] [-l|--full] [--fields]", + Short: "List the current state of units in the cluster", + Long: `Lists the state of all units in the cluster loaded onto a machine. + +For easily parsable output, you can remove the column headers: +fleetctl list-units --no-legend + +Output the list without ellipses: +fleetctl list-units --full + +Or, choose the columns to display: +fleetctl list-units --fields=unit,machine`, + Run: runWrapper(runListUnits), +} + +func init() { + cmdFleet.AddCommand(cmdListUnits) + + cmdListUnits.Flags().BoolVar(&sharedFlags.Full, "full", false, "Do not ellipsize fields on output") + cmdListUnits.Flags().BoolVar(&sharedFlags.Full, "l", false, "Shorthand for --full") + cmdListUnits.Flags().BoolVar(&sharedFlags.NoLegend, "no-legend", false, "Do not print a legend (column headers)") + cmdListUnits.Flags().StringVar(&listUnitsFieldsFlag, "fields", defaultListUnitsFields, fmt.Sprintf("Columns to print for each Unit. Valid fields are %q", strings.Join(usToFieldKeys(listUnitsFields), ","))) +} + +func runListUnits(cCmd *cobra.Command, args []string) (exit int) { if listUnitsFieldsFlag == "" { stderr("Must define output format") return 1 @@ -125,21 +125,22 @@ func runListUnits(c *cli.Context, cAPI client.API) (exit int) { return 1 } - if !c.Bool("no-legend") { + noLegend, _ := cCmd.Flags().GetBool("no-legend") + if !noLegend { fmt.Fprintln(out, strings.ToUpper(strings.Join(cols, "\t"))) } + full, _ := cCmd.Flags().GetBool("full") for _, us := range states { var f []string - for _, col := range cols { - f = append(f, listUnitsFields[col](us, c.Bool("full"))) + for _, c := range cols { + f = append(f, listUnitsFields[c](us, full)) } fmt.Fprintln(out, strings.Join(f, "\t")) } out.Flush() - - return + return 0 } func usToFieldKeys(m map[string]usToField) (keys []string) { diff --git a/fleetctl/load.go b/fleetctl/load.go index 977825da4..e14dc8234 100644 --- a/fleetctl/load.go +++ b/fleetctl/load.go @@ -17,18 +17,15 @@ package main import ( "os" - "github.com/codegangsta/cli" + "github.com/spf13/cobra" - "github.com/coreos/fleet/client" "github.com/coreos/fleet/job" ) -func NewLoadUnitsCommand() cli.Command { - return cli.Command{ - Name: "load", - Usage: "Schedule one or more units in the cluster, first submitting them if necessary.", - ArgsUsage: "[--no-block|--block-attempts=N] UNIT...", - Description: `Load one or many units in the cluster into systemd, but do not start. +var cmdLoad = &cobra.Command{ + Use: "load [--no-block|--block-attempts=N] UNIT...", + Short: "Schedule one or more units in the cluster, first submitting them if necessary.", + Long: `Load one or many units in the cluster into systemd, but do not start. Select units to load by glob matching for units in the current working directory or matching the names of previously submitted units. @@ -38,24 +35,25 @@ which means fleetctl will block until it detects that the unit(s) have transitioned to a loaded state. This behaviour can be configured with the respective --block-attempts and --no-block options. Load operations on global units are always non-blocking.`, - Action: makeActionWrapper(runLoadUnits), - Flags: []cli.Flag{ - cli.BoolFlag{Name: "sign", Usage: "DEPRECATED - this option cannot be used"}, - cli.IntFlag{Name: "block-attempts", Value: 0, Usage: "ait until the jobs are loaded, performing up to N attempts before giving up. A value of 0 indicates no limit. Does not apply to global units."}, - cli.BoolFlag{Name: "no-block", Usage: "Do not wait until the jobs have been loaded before exiting. Always the case for global units."}, - cli.BoolFlag{Name: "replace", Usage: "Replace the old scheduled units in the cluster with new versions."}, - }, - } + Run: runWrapper(runLoadUnit), +} + +func init() { + cmdFleet.AddCommand(cmdLoad) + + cmdLoad.Flags().BoolVar(&sharedFlags.Sign, "sign", false, "DEPRECATED - this option cannot be used") + cmdLoad.Flags().IntVar(&sharedFlags.BlockAttempts, "block-attempts", 0, "Wait until the jobs are loaded, performing up to N attempts before giving up. A value of 0 indicates no limit. Does not apply to global units.") + cmdLoad.Flags().BoolVar(&sharedFlags.NoBlock, "no-block", false, "Do not wait until the jobs have been loaded before exiting. Always the case for global units.") + cmdLoad.Flags().BoolVar(&sharedFlags.Replace, "replace", false, "Replace the old scheduled units in the cluster with new versions.") } -func runLoadUnits(c *cli.Context, cAPI client.API) (exit int) { - args := c.Args() +func runLoadUnit(cCmd *cobra.Command, args []string) (exit int) { if len(args) == 0 { stderr("No units given") return 0 } - if err := lazyCreateUnits(c); err != nil { + if err := lazyCreateUnits(cCmd, args); err != nil { stderr("Error creating units: %v", err) return 1 } @@ -75,7 +73,11 @@ func runLoadUnits(c *cli.Context, cAPI client.API) (exit int) { } } - exit = tryWaitForUnitStates(loading, "load", job.JobStateLoaded, getBlockAttempts(c), os.Stdout) + exitVal := tryWaitForUnitStates(loading, "load", job.JobStateLoaded, getBlockAttempts(cCmd), os.Stdout) + if exitVal != 0 { + stderr("Error waiting for unit states, exit status: %d", exitVal) + return 1 + } - return + return 0 } diff --git a/fleetctl/ssh.go b/fleetctl/ssh.go index caf2a1c20..7835209cd 100644 --- a/fleetctl/ssh.go +++ b/fleetctl/ssh.go @@ -24,53 +24,60 @@ import ( "strings" "syscall" - "github.com/codegangsta/cli" + "github.com/spf13/cobra" - "github.com/coreos/fleet/client" + // "github.com/coreos/fleet/client" "github.com/coreos/fleet/machine" "github.com/coreos/fleet/pkg" "github.com/coreos/fleet/ssh" ) -func NewSSHCommend() cli.Command { - return cli.Command{ - Name: "ssh", - Usage: "Open interactive shell on a machine in the cluster", - ArgsUsage: "[-A|--forward-agent] [--ssh-port=N] [--machine|--unit] {MACHINE|UNIT}", - Description: `Open an interactive shell on a specific machine in the cluster or on the machine where the specified unit is located. +var ( + flagMachine string + flagUnit string + flagSSHAgentForwarding bool +) + +var cmdSSH = &cobra.Command{ + Use: "ssh [-A|--forward-agent] [--ssh-port=N] [--machine|--unit] {MACHINE|UNIT}", + Short: "Open interactive shell on a machine in the cluster", + Long: `Open an interactive shell on a specific machine in the cluster or on the machine +where the specified unit is located. fleetctl tries to detect whether your first argument is a machine or a unit. To skip this check use the --machine or --unit flags. Open a shell on a machine: - fleetctl ssh 2444264c-eac2-4eff-a490-32d5e5e4af24 +fleetctl ssh 2444264c-eac2-4eff-a490-32d5e5e4af24 Open a shell from your laptop, to the machine running a specific unit, using a cluster member as a bastion host: - fleetctl --tunnel 10.10.10.10 ssh foo.service +fleetctl --tunnel 10.10.10.10 ssh foo.service Open a shell on a machine and forward the authentication agent connection: - fleetctl ssh --forward-agent 2444264c-eac2-4eff-a490-32d5e5e4af24 +fleetctl ssh --forward-agent 2444264c-eac2-4eff-a490-32d5e5e4af24 Tip: Create an alias for --tunnel. - - Add "alias fleetctl=fleetctl --tunnel 10.10.10.10" to your bash profile. - - Now you can run all fleet commands locally. +- Add "alias fleetctl=fleetctl --tunnel 10.10.10.10" to your bash profile. +- Now you can run all fleet commands locally. This command does not work with global units.`, - Action: makeActionWrapper(runSSH), - Flags: []cli.Flag{ - cli.StringFlag{Name: "machine", Value: "", Usage: "Open SSH connection to a specific machine."}, - cli.StringFlag{Name: "unit", Value: "", Usage: "Open SSH connection to machine running provided unit."}, - cli.BoolFlag{Name: "forward-agent, A", Usage: "forward local ssh-agent to target machine."}, - cli.IntFlag{Name: "ssh-port", Value: 22, Usage: "Connect to remote hosts over SSH using this TCP port."}, - }, - } + Run: runWrapper(runSSH), } -func runSSH(c *cli.Context, cAPI client.API) (exit int) { - args := c.Args() - if c.String("unit") != "" && c.String("machine") != "" { +func init() { + cmdFleet.AddCommand(cmdSSH) + + cmdSSH.Flags().StringVar(&flagMachine, "machine", "", "Open SSH connection to a specific machine.") + cmdSSH.Flags().StringVar(&flagUnit, "unit", "", "Open SSH connection to machine running provided unit.") + cmdSSH.Flags().BoolVar(&flagSSHAgentForwarding, "forward-agent", false, "Forward local ssh-agent to target machine.") + cmdSSH.Flags().BoolVar(&flagSSHAgentForwarding, "A", false, "Shorthand for --forward-agent") + cmdSSH.Flags().IntVar(&sharedFlags.SSHPort, "ssh-port", 22, "Connect to remote hosts over SSH using this TCP port.") +} + +func runSSH(cCmd *cobra.Command, args []string) (exit int) { + if flagUnit != "" && flagMachine != "" { stderr("Both machine and unit flags provided, please specify only one.") return 1 } @@ -79,10 +86,10 @@ func runSSH(c *cli.Context, cAPI client.API) (exit int) { var addr string switch { - case c.String("machine") != "": - addr, _, err = findAddressInMachineList(c.String("machine")) - case c.String("unit") != "": - addr, _, err = findAddressInRunningUnits(c.String("unit")) + case flagMachine != "": + addr, _, err = findAddressInMachineList(flagMachine) + case flagUnit != "": + addr, _, err = findAddressInRunningUnits(flagUnit) default: addr, err = globalMachineLookup(args) // trim machine/unit name from args @@ -101,16 +108,16 @@ func runSSH(c *cli.Context, cAPI client.API) (exit int) { return 1 } - addr = findSSHPort(addr, c) + addr = findSSHPort(cCmd, addr) args = pkg.TrimToDashes(args) var sshClient *ssh.SSHForwardingClient - timeout := getSSHTimeoutFlag(c) - if tun := getTunnelFlag(c); tun != "" { - sshClient, err = ssh.NewTunnelledSSHClient(c.GlobalString("ssh-username"), tun, addr, getChecker(c), c.Bool("forward-agent"), timeout) + timeout := getSSHTimeoutFlag(cCmd) + if tun := getTunnelFlag(cCmd); tun != "" { + sshClient, err = ssh.NewTunnelledSSHClient(globalFlags.SSHUserName, tun, addr, getChecker(cCmd), flagSSHAgentForwarding, timeout) } else { - sshClient, err = ssh.NewSSHClient(c.GlobalString("ssh-username"), addr, getChecker(c), c.Bool("forward-agent"), timeout) + sshClient, err = ssh.NewSSHClient(globalFlags.SSHUserName, addr, getChecker(cCmd), flagSSHAgentForwarding, timeout) } if err != nil { stderr("Failed building SSH client: %v", err) @@ -128,16 +135,16 @@ func runSSH(c *cli.Context, cAPI client.API) (exit int) { } else { if err := ssh.Shell(sshClient); err != nil { stderr("Failed opening shell over SSH: %v", err) - return 1 + exit = 1 } } - return } -func findSSHPort(addr string, c *cli.Context) string { - if c.Int("ssh-port") != 22 && !strings.Contains(addr, ":") { - return net.JoinHostPort(addr, strconv.Itoa(c.Int("ssh-port"))) +func findSSHPort(cCmd *cobra.Command, addr string) string { + SSHPort, _ := cCmd.Flags().GetInt("ssh-port") + if SSHPort != 22 && !strings.Contains(addr, ":") { + return net.JoinHostPort(addr, strconv.Itoa(SSHPort)) } else { return addr } @@ -213,7 +220,7 @@ func findAddressInRunningUnits(name string) (string, bool, error) { // runCommand will attempt to run a command on a given machine. It will attempt // to SSH to the machine if it is identified as being remote. -func runCommand(c *cli.Context, machID string, cmd string, args ...string) (retcode int) { +func runCommand(cCmd *cobra.Command, machID string, cmd string, args ...string) (retcode int) { var err error if machine.IsLocalMachineID(machID) { err, retcode = runLocalCommand(cmd, args...) @@ -225,8 +232,8 @@ func runCommand(c *cli.Context, machID string, cmd string, args ...string) (retc if err != nil || ms == nil { stderr("Error getting machine IP: %v", err) } else { - addr := findSSHPort(ms.PublicIP, c) - err, retcode = runRemoteCommand(c, addr, cmd, args...) + addr := findSSHPort(cCmd, ms.PublicIP) + err, retcode = runRemoteCommand(cCmd, addr, cmd, args...) if err != nil { stderr("Error running remote command: %v", err) } @@ -257,13 +264,13 @@ func runLocalCommand(cmd string, args ...string) (error, int) { // runRemoteCommand runs the given command over SSH on the given IP, and returns // any error encountered and the exit status of the command -func runRemoteCommand(c *cli.Context, addr string, cmd string, args ...string) (err error, exit int) { +func runRemoteCommand(cCmd *cobra.Command, addr string, cmd string, args ...string) (err error, exit int) { var sshClient *ssh.SSHForwardingClient - timeout := getSSHTimeoutFlag(c) - if tun := getTunnelFlag(c); tun != "" { - sshClient, err = ssh.NewTunnelledSSHClient(c.GlobalString("ssh-username"), tun, addr, getChecker(c), false, timeout) + timeout := getSSHTimeoutFlag(cCmd) + if tun := getTunnelFlag(cCmd); tun != "" { + sshClient, err = ssh.NewTunnelledSSHClient(globalFlags.SSHUserName, tun, addr, getChecker(cCmd), false, timeout) } else { - sshClient, err = ssh.NewSSHClient(c.GlobalString("ssh-username"), addr, getChecker(c), false, timeout) + sshClient, err = ssh.NewSSHClient(globalFlags.SSHUserName, addr, getChecker(cCmd), false, timeout) } if err != nil { return err, -1 diff --git a/fleetctl/start.go b/fleetctl/start.go index 2ad4ce690..bb40f2d98 100644 --- a/fleetctl/start.go +++ b/fleetctl/start.go @@ -17,18 +17,17 @@ package main import ( "os" - "github.com/codegangsta/cli" + "github.com/spf13/cobra" - "github.com/coreos/fleet/client" "github.com/coreos/fleet/job" ) -func NewStartCommand() cli.Command { - return cli.Command{ - Name: "start", - Usage: "Instruct systemd to start one or more units in the cluster, first submitting and loading if necessary.", - ArgsUsage: "[--no-block|--block-attempts=N] UNIT...", - Description: `Start one or many units on the cluster. Select units to start by glob matching for units in the current working directory or matching names of previously submitted units. +var cmdStart = &cobra.Command{ + Use: "start [--no-block|--block-attempts=N] UNIT...", + Short: "Instruct systemd to start one or more units in the cluster, first submitting and loading if necessary.", + Long: `Start one or many units on the cluster. Select units to start by glob matching +for units in the current working directory or matching names of previously +submitted units. For units which are not global, start operations are performed synchronously, which means fleetctl will block until it detects that the unit(s) have @@ -37,31 +36,32 @@ respective --block-attempts and --no-block options. Start operations on global units are always non-blocking. Start a single unit: - fleetctl start foo.service +fleetctl start foo.service Start an entire directory of units with glob matching: - fleetctl start myservice/* +fleetctl start myservice/* You may filter suitable hosts based on metadata provided by the machine. Machine metadata is located in the fleet configuration file.`, - Action: makeActionWrapper(runStartUnit), - Flags: []cli.Flag{ - cli.BoolFlag{Name: "sign", Usage: "DEPRECATED - this option cannot be used"}, - cli.IntFlag{Name: "block-attempts", Value: 0, Usage: "Wait until the units are launched, performing up to N attempts before giving up. A value of 0 indicates no limit. Does not apply to global units."}, - cli.BoolFlag{Name: "no-block", Usage: "Do not wait until the units have launched before exiting. Always the case for global units."}, - cli.BoolFlag{Name: "replace", Usage: "Replace the already started units in the cluster with new versions."}, - }, - } + Run: runWrapper(runStartUnit), +} + +func init() { + cmdFleet.AddCommand(cmdStart) + + cmdStart.Flags().BoolVar(&sharedFlags.Sign, "sign", false, "DEPRECATED - this option cannot be used") + cmdStart.Flags().IntVar(&sharedFlags.BlockAttempts, "block-attempts", 0, "Wait until the units are launched, performing up to N attempts before giving up. A value of 0 indicates no limit. Does not apply to global units.") + cmdStart.Flags().BoolVar(&sharedFlags.NoBlock, "no-block", false, "Do not wait until the units have launched before exiting. Always the case for global units.") + cmdStart.Flags().BoolVar(&sharedFlags.Replace, "replace", false, "Replace the already started units in the cluster with new versions.") } -func runStartUnit(c *cli.Context, cAPI client.API) (exit int) { - args := c.Args() +func runStartUnit(cCmd *cobra.Command, args []string) (exit int) { if len(args) == 0 { stderr("No units given") return 0 } - if err := lazyCreateUnits(c); err != nil { + if err := lazyCreateUnits(cCmd, args); err != nil { stderr("Error creating units: %v", err) return 1 } @@ -81,6 +81,11 @@ func runStartUnit(c *cli.Context, cAPI client.API) (exit int) { } } - exit = tryWaitForUnitStates(starting, "start", job.JobStateLaunched, getBlockAttempts(c), os.Stdout) - return + exitVal := tryWaitForUnitStates(starting, "start", job.JobStateLaunched, getBlockAttempts(cCmd), os.Stdout) + if exitVal != 0 { + stderr("Error waiting for unit states, exit status: %d", exitVal) + return exitVal + } + + return 0 } diff --git a/fleetctl/status.go b/fleetctl/status.go index ef9cacf7e..5f85399f1 100644 --- a/fleetctl/status.go +++ b/fleetctl/status.go @@ -17,37 +17,35 @@ package main import ( "fmt" - "github.com/codegangsta/cli" + "github.com/spf13/cobra" - "github.com/coreos/fleet/client" "github.com/coreos/fleet/job" ) -func NewStatusCommand() cli.Command { - return cli.Command{ - Name: "status", - Usage: "Output the status of one or more units in the cluster", - ArgsUsage: "[--ssh-port=N] UNIT...", - Description: `Output the status of one or more units currently running in the cluster. +var cmdStatus = &cobra.Command{ + Use: "status [--ssh-port=N] UNIT...", + Short: "Output the status of one or more units in the cluster", + Long: `Output the status of one or more units currently running in the cluster. Supports glob matching of units in the current working directory or matches previously started units. Show status of a single unit: - fleetctl status foo.service + fleetctl status foo.service Show status of an entire directory with glob matching: fleetctl status myservice/* This command does not work with global units.`, - Action: makeActionWrapper(runStatusUnits), - Flags: []cli.Flag{ - cli.IntFlag{Name: "ssh-port", Value: 22, Usage: "Connect to remote hosts over SSH using this TCP port."}, - }, - } + Run: runWrapper(runStatusUnit), +} + +func init() { + cmdFleet.AddCommand(cmdStatus) + + cmdStatus.Flags().IntVar(&sharedFlags.SSHPort, "ssh-port", 22, "Connect to remote hosts over SSH using this TCP port.") } -func runStatusUnits(c *cli.Context, cAPI client.API) (exit int) { - args := c.Args() +func runStatusUnit(cCmd *cobra.Command, args []string) (exit int) { for i, arg := range args { name := unitNameMangle(arg) unit, err := cAPI.Unit(name) @@ -72,7 +70,8 @@ func runStatusUnits(c *cli.Context, cAPI client.API) (exit int) { fmt.Printf("\n") } - if exit = runCommand(c, unit.MachineID, "systemctl", "status", "-l", unit.Name); exit != 0 { + if exitVal := runCommand(cCmd, unit.MachineID, "systemctl", "status", "-l", unit.Name); exitVal != 0 { + exit = exitVal break } } diff --git a/fleetctl/stop.go b/fleetctl/stop.go index 7ba790ead..2b03c51b6 100644 --- a/fleetctl/stop.go +++ b/fleetctl/stop.go @@ -17,19 +17,17 @@ package main import ( "os" - "github.com/codegangsta/cli" + "github.com/spf13/cobra" - "github.com/coreos/fleet/client" "github.com/coreos/fleet/job" "github.com/coreos/fleet/log" ) -func NewStopUnitCommand() cli.Command { - return cli.Command{ - Name: "stop", - Usage: "Instruct systemd to stop one or more units in the cluster.", - ArgsUsage: "[--no-block|--block-attempts=N] UNIT...", - Description: `Stop one or more units from running in the cluster, but allow them to be started again in the future. +var cmdStop = &cobra.Command{ + Use: "stop [--no-block|--block-attempts=N] UNIT...", + Short: "Instruct systemd to stop one or more units in the cluster.", + Long: `Stop one or more units from running in the cluster, but allow them to be +started again in the future. Instructs systemd on the host machine to stop the unit, deferring to systemd completely for any custom stop directives (i.e. ExecStop option in the unit @@ -42,20 +40,21 @@ respective --block-attempts and --no-block options. Stop operations on global units are always non-blocking. Stop a single unit: - fleetctl stop foo.service +fleetctl stop foo.service Stop an entire directory of units with glob matching, without waiting: - fleetctl --no-block stop myservice/*`, - Action: makeActionWrapper(runStopUnit), - Flags: []cli.Flag{ - cli.IntFlag{Name: "block-attempts", Value: 22, Usage: "Wait until the units are stopped, performing up to N attempts before giving up. A value of 0 indicates no limit. Does not apply to global units."}, - cli.BoolFlag{Name: "no-block", Usage: "Do not wait until the units have stopped before exiting. Always the case for global units."}, - }, - } +fleetctl --no-block stop myservice/*`, + Run: runWrapper(runStopUnit), +} + +func init() { + cmdFleet.AddCommand(cmdStop) + + cmdStop.Flags().IntVar(&sharedFlags.BlockAttempts, "block-attempts", 0, "Wait until the units are stopped, performing up to N attempts before giving up. A value of 0 indicates no limit. Does not apply to global units.") + cmdStop.Flags().BoolVar(&sharedFlags.NoBlock, "no-block", false, "Do not wait until the units have stopped before exiting. Always the case for global units.") } -func runStopUnit(c *cli.Context, cAPI client.API) (exit int) { - args := c.Args() +func runStopUnit(cCmd *cobra.Command, args []string) (exit int) { if len(args) == 0 { stderr("No units given") return 0 @@ -88,7 +87,7 @@ func runStopUnit(c *cli.Context, cAPI client.API) (exit int) { } } - exit = tryWaitForUnitStates(stopping, "stop", job.JobStateLoaded, getBlockAttempts(c), os.Stdout) + exit = tryWaitForUnitStates(stopping, "stop", job.JobStateLoaded, getBlockAttempts(cCmd), os.Stdout) if exit == 0 { stderr("Successfully stopped units %v.", stopping) } else { diff --git a/fleetctl/submit.go b/fleetctl/submit.go index fc55aaaf9..b5ef4b874 100644 --- a/fleetctl/submit.go +++ b/fleetctl/submit.go @@ -15,44 +15,41 @@ package main import ( - "github.com/codegangsta/cli" - - "github.com/coreos/fleet/client" + "github.com/spf13/cobra" ) -func NewSubmitUnitCommand() cli.Command { - return cli.Command{ - Name: "submit", - Usage: "Upload one or more units to the cluster without starting them", - ArgsUsage: "UNIT...", - Description: `Upload one or more units to the cluster without starting them. Useful for validating units before they are started. +var cmdSubmit = &cobra.Command{ + Use: "submit UNIT...", + Short: "Upload one or more units to the cluster without starting them", + Long: `Upload one or more units to the cluster without starting them. Useful +for validating units before they are started. This operation is idempotent; if a named unit already exists in the cluster, it will not be resubmitted. Submit a single unit: - fleetctl submit foo.service +fleetctl submit foo.service Submit a directory of units with glob matching: - fleetctl submit myservice/*`, - Action: makeActionWrapper(runSubmitUnits), - Flags: []cli.Flag{ - cli.BoolFlag{Name: "sign", Usage: "DEPRECATED - this option cannot be used"}, - cli.BoolFlag{Name: "replace", Usage: "Replace the old submitted units in the cluster with new versions."}, - }, - } +fleetctl submit myservice/*`, + Run: runWrapper(runSubmitUnit), +} + +func init() { + cmdFleet.AddCommand(cmdSubmit) + + cmdSubmit.Flags().BoolVar(&sharedFlags.Sign, "sign", false, "DEPRECATED - this option cannot be used") + cmdSubmit.Flags().BoolVar(&sharedFlags.Replace, "replace", false, "Replace the old submitted units in the cluster with new versions.") } -func runSubmitUnits(c *cli.Context, cAPI client.API) (exit int) { - args := c.Args() +func runSubmitUnit(cCmd *cobra.Command, args []string) (exit int) { if len(args) == 0 { stderr("No units given") return 0 } - if err := lazyCreateUnits(c); err != nil { + if err := lazyCreateUnits(cCmd, args); err != nil { stderr("Error creating units: %v", err) - exit = 1 + return 1 } - - return + return 0 } diff --git a/fleetctl/unload.go b/fleetctl/unload.go index d7a98fdea..238b89993 100644 --- a/fleetctl/unload.go +++ b/fleetctl/unload.go @@ -17,28 +17,26 @@ package main import ( "os" - "github.com/codegangsta/cli" + "github.com/spf13/cobra" - "github.com/coreos/fleet/client" "github.com/coreos/fleet/job" "github.com/coreos/fleet/log" ) -func NewUnloadUnitCommand() cli.Command { - return cli.Command{ - Name: "unload", - Usage: "Unschedule one or more units in the cluster.", - ArgsUsage: "UNIT...", - Action: makeActionWrapper(runUnloadUnit), - Flags: []cli.Flag{ - cli.IntFlag{Name: "block-attempts", Value: 0, Usage: "Wait until the units are inactive, performing up to N attempts before giving up. A value of 0 indicates no limit."}, - cli.BoolFlag{Name: "no-block", Usage: "Do not wait until the units have become inactive before exiting."}, - }, - } +var cmdUnload = &cobra.Command{ + Use: "unload UNIT...", + Short: "Unschedule one or more units in the cluster.", + Run: runWrapper(runUnloadUnit), +} + +func init() { + cmdFleet.AddCommand(cmdUnload) + + cmdUnload.Flags().IntVar(&sharedFlags.BlockAttempts, "block-attempts", 0, "Wait until the units are inactive, performing up to N attempts before giving up. A value of 0 indicates no limit.") + cmdUnload.Flags().BoolVar(&sharedFlags.NoBlock, "no-block", false, "Do not wait until the units have become inactive before exiting.") } -func runUnloadUnit(c *cli.Context, cAPI client.API) (exit int) { - args := c.Args() +func runUnloadUnit(cCmd *cobra.Command, args []string) (exit int) { if len(args) == 0 { stderr("No units given") return 0 @@ -68,7 +66,7 @@ func runUnloadUnit(c *cli.Context, cAPI client.API) (exit int) { } } - exit = tryWaitForUnitStates(wait, "unload", job.JobStateInactive, getBlockAttempts(c), os.Stdout) + exit = tryWaitForUnitStates(wait, "unload", job.JobStateInactive, getBlockAttempts(cCmd), os.Stdout) if exit == 0 { stderr("Successfully unloaded units %v.", wait) } else { diff --git a/fleetctl/verify.go b/fleetctl/verify.go index 2081982b2..b54b607d8 100644 --- a/fleetctl/verify.go +++ b/fleetctl/verify.go @@ -15,21 +15,20 @@ package main import ( - "github.com/codegangsta/cli" - - "github.com/coreos/fleet/client" + "github.com/spf13/cobra" ) -func NewVerifyCommand() cli.Command { - return cli.Command{ - Name: "verify", - Usage: "DEPRECATED - No longer works", - ArgsUsage: "UNIT", - Action: makeActionWrapper(runVerifyUnit), - } +var cmdVerifyUnit = &cobra.Command{ + Use: "verify UNIT", + Deprecated: "DEPRECATED - No longer works", + Run: runWrapper(runVerifyUnit), +} + +func init() { + cmdFleet.AddCommand(cmdVerifyUnit) } -func runVerifyUnit(c *cli.Context, cAPI client.API) (exit int) { +func runVerifyUnit(cCmd *cobra.Command, args []string) (exit int) { stderr("WARNING: The signed/verified units feature is DEPRECATED and cannot be used.") return 2 } diff --git a/fleetctl/version.go b/fleetctl/version.go new file mode 100644 index 000000000..2b5eb3894 --- /dev/null +++ b/fleetctl/version.go @@ -0,0 +1,37 @@ +// Copyright 2016 CoreOS, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE+2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package main + +import ( + "github.com/spf13/cobra" + + "github.com/coreos/fleet/version" +) + +var cmdVersion = &cobra.Command{ + Use: "version", + Short: "Print the version and exit", + Long: "Print the version and exit", + Run: runWrapper(runVersion), +} + +func init() { + cmdFleet.AddCommand(cmdVersion) +} + +func runVersion(cCmd *cobra.Command, args []string) (exit int) { + stdout("fleetctl version %s", version.Version) + return 0 +} From d4e55243b42994d2196035133ce3275df3681287 Mon Sep 17 00:00:00 2001 From: Dongsu Park Date: Fri, 20 May 2016 09:44:47 +0200 Subject: [PATCH 5/6] fleetctl: use cobra also for unit tests As every fleetctl command uses cobra instead of codegangsta/cli, we need to update unit tests as well. --- fleetctl/destroy_test.go | 16 +++++----------- fleetctl/fleetctl_test.go | 39 +++++++++++---------------------------- fleetctl/load_test.go | 19 ++++++++++--------- fleetctl/start_test.go | 15 +++++++++------ fleetctl/stop_test.go | 20 ++++++++++---------- fleetctl/submit_test.go | 16 +++++++++------- fleetctl/unload_test.go | 20 ++++++++++---------- 7 files changed, 64 insertions(+), 81 deletions(-) diff --git a/fleetctl/destroy_test.go b/fleetctl/destroy_test.go index 7dfde0727..182506336 100644 --- a/fleetctl/destroy_test.go +++ b/fleetctl/destroy_test.go @@ -18,14 +18,10 @@ import ( "fmt" "sync" "testing" - - "github.com/codegangsta/cli" - - "github.com/coreos/fleet/client" ) -func doDestroyUnits(t *testing.T, r commandTestResults, errchan chan error, cAPI client.API, c *cli.Context) { - exit := runDestroyUnits(c, cAPI) +func doDestroyUnits(t *testing.T, r commandTestResults, errchan chan error) { + exit := runDestroyUnit(cmdDestroy, r.units) if exit != r.expectedExit { errchan <- fmt.Errorf("%s: expected exit code %d but received %d", r.description, r.expectedExit, exit) return @@ -72,18 +68,16 @@ func TestRunDestroyUnits(t *testing.T) { var wg sync.WaitGroup errchan := make(chan error) - cAPI := newFakeRegistryForCommands(unitPrefix, len(r.units), false) - - c := createTestContext(t, append([]string{"destroy"}, r.units...)...) + cAPI = newFakeRegistryForCommands(unitPrefix, len(r.units), false) wg.Add(2) go func() { defer wg.Done() - doDestroyUnits(t, r, errchan, cAPI, c) + doDestroyUnits(t, r, errchan) }() go func() { defer wg.Done() - doDestroyUnits(t, r, errchan, cAPI, c) + doDestroyUnits(t, r, errchan) }() go func() { diff --git a/fleetctl/fleetctl_test.go b/fleetctl/fleetctl_test.go index ace7f8180..ea6ff075d 100644 --- a/fleetctl/fleetctl_test.go +++ b/fleetctl/fleetctl_test.go @@ -26,7 +26,6 @@ import ( "github.com/coreos/fleet/unit" "github.com/coreos/fleet/version" - "github.com/codegangsta/cli" "github.com/coreos/go-semver/semver" ) @@ -140,26 +139,6 @@ func newFakeRegistryForCheckVersion(v string) registry.ClusterRegistry { return registry.NewFakeClusterRegistry(sv, 0) } -func createTestContext(t *testing.T, args ...string) *cli.Context { - var c *cli.Context - app := createApp() - - stderr("args: %v", args) - action := func(ctx *cli.Context) { - c = ctx - } - app.Action = action - for i := range app.Commands { - app.Commands[i].Action = action - } - - if err := app.Run(append([]string{"fleetctl"}, args...)); err != nil { - t.Fatalf("Run error: %s", err) - } - - return c -} - func TestCheckVersion(t *testing.T) { reg := newFakeRegistryForCheckVersion(version.Version) _, ok := checkVersion(reg) @@ -243,6 +222,14 @@ func TestUnitNameMangle(t *testing.T) { } func TestGetBlockAttempts(t *testing.T) { + oldNoBlock := sharedFlags.NoBlock + oldBlockAttempts := sharedFlags.BlockAttempts + + defer func() { + sharedFlags.NoBlock = oldNoBlock + sharedFlags.BlockAttempts = oldBlockAttempts + }() + var blocktests = []struct { noBlock bool blockAttempts int @@ -257,13 +244,9 @@ func TestGetBlockAttempts(t *testing.T) { } for _, tt := range blocktests { - var c *cli.Context - if tt.noBlock { - c = createTestContext(t, "load", "--no-block", "--block-attempts", fmt.Sprintf("%d", tt.blockAttempts), "none") - } else { - c = createTestContext(t, "load", "--block-attempts", fmt.Sprintf("%d", tt.blockAttempts), "none") - } - if n := getBlockAttempts(c); n != tt.expected { + sharedFlags.NoBlock = tt.noBlock + sharedFlags.BlockAttempts = tt.blockAttempts + if n := getBlockAttempts(cmdFleet); n != tt.expected { t.Errorf("got %d, want %d (for --no-block=%t, --block-attempts=%d)", n, tt.expected, tt.noBlock, tt.blockAttempts) } } diff --git a/fleetctl/load_test.go b/fleetctl/load_test.go index 97201a3da..8cbb2af22 100644 --- a/fleetctl/load_test.go +++ b/fleetctl/load_test.go @@ -19,9 +19,6 @@ import ( "sync" "testing" - "github.com/codegangsta/cli" - - "github.com/coreos/fleet/client" "github.com/coreos/fleet/job" "github.com/coreos/fleet/schema" ) @@ -38,8 +35,9 @@ func checkLoadUnitState(unit schema.Unit, loadRet int, errchan chan error) { } } -func doLoadUnits(t *testing.T, r commandTestResults, errchan chan error, cAPI client.API, c *cli.Context) { - exit := runLoadUnits(c, cAPI) +func doLoadUnits(t *testing.T, r commandTestResults, errchan chan error) { + sharedFlags.NoBlock = true + exit := runLoadUnit(cmdLoad, r.units) if exit != r.expectedExit { errchan <- fmt.Errorf("%s: expected exit code %d but received %d", r.description, r.expectedExit, exit) return @@ -58,6 +56,10 @@ func doLoadUnits(t *testing.T, r commandTestResults, errchan chan error, cAPI cl func TestRunLoadUnits(t *testing.T) { unitPrefix := "load" + oldNoBlock := sharedFlags.NoBlock + defer func() { + sharedFlags.NoBlock = oldNoBlock + }() results := []commandTestResults{ { @@ -86,17 +88,16 @@ func TestRunLoadUnits(t *testing.T) { var wg sync.WaitGroup errchan := make(chan error) - cAPI := newFakeRegistryForCommands(unitPrefix, len(r.units), false) + cAPI = newFakeRegistryForCommands(unitPrefix, len(r.units), false) - c := createTestContext(t, append([]string{"load", "--no-block"}, r.units...)...) wg.Add(2) go func() { defer wg.Done() - doLoadUnits(t, r, errchan, cAPI, c) + doLoadUnits(t, r, errchan) }() go func() { defer wg.Done() - doLoadUnits(t, r, errchan, cAPI, c) + doLoadUnits(t, r, errchan) }() go func() { diff --git a/fleetctl/start_test.go b/fleetctl/start_test.go index 70830a48c..64c618d27 100644 --- a/fleetctl/start_test.go +++ b/fleetctl/start_test.go @@ -19,7 +19,6 @@ import ( "sync" "testing" - "github.com/coreos/fleet/client" "github.com/coreos/fleet/job" "github.com/coreos/fleet/schema" ) @@ -36,9 +35,9 @@ func checkStartUnitState(unit schema.Unit, startRet int, errchan chan error) { } } -func doStartUnits(t *testing.T, r commandTestResults, errchan chan error, cAPI client.API) { - c := createTestContext(t, append([]string{"start", "--no-block"}, r.units...)...) - exit := runStartUnit(c, cAPI) +func doStartUnits(t *testing.T, r commandTestResults, errchan chan error) { + sharedFlags.NoBlock = true + exit := runStartUnit(cmdStart, r.units) if exit != r.expectedExit { errchan <- fmt.Errorf("%s: expected exit code %d but received %d", r.description, r.expectedExit, exit) return @@ -65,11 +64,11 @@ func runStartUnits(t *testing.T, unitPrefix string, results []commandTestResults unitsCount = len(r.units) } - cAPI := newFakeRegistryForCommands(unitPrefix, unitsCount, template) + cAPI = newFakeRegistryForCommands(unitPrefix, unitsCount, template) wg.Add(1) go func() { defer wg.Done() - doStartUnits(t, r, errchan, cAPI) + doStartUnits(t, r, errchan) }() go func() { @@ -85,6 +84,10 @@ func runStartUnits(t *testing.T, unitPrefix string, results []commandTestResults func TestRunStartUnits(t *testing.T) { unitPrefix := "start" + oldNoBlock := sharedFlags.NoBlock + defer func() { + sharedFlags.NoBlock = oldNoBlock + }() results := []commandTestResults{ { diff --git a/fleetctl/stop_test.go b/fleetctl/stop_test.go index 5e2dd5b1b..ad2f0483f 100644 --- a/fleetctl/stop_test.go +++ b/fleetctl/stop_test.go @@ -19,14 +19,12 @@ import ( "sync" "testing" - "github.com/codegangsta/cli" - - "github.com/coreos/fleet/client" "github.com/coreos/fleet/job" ) -func doStopUnits(t *testing.T, r commandTestResults, errchan chan error, cAPI client.API, c *cli.Context) { - exit := runStopUnit(c, cAPI) +func doStopUnits(t *testing.T, r commandTestResults, errchan chan error) { + sharedFlags.NoBlock = true + exit := runStopUnit(cmdStop, r.units) if exit != r.expectedExit { errchan <- fmt.Errorf("%s: expected exit code %d but received %d", r.description, r.expectedExit, exit) return @@ -48,6 +46,10 @@ func doStopUnits(t *testing.T, r commandTestResults, errchan chan error, cAPI cl func TestRunStopUnits(t *testing.T) { unitPrefix := "stop" + oldNoBlock := sharedFlags.NoBlock + defer func() { + sharedFlags.NoBlock = oldNoBlock + }() results := []commandTestResults{ { @@ -76,18 +78,16 @@ func TestRunStopUnits(t *testing.T) { var wg sync.WaitGroup errchan := make(chan error) - cAPI := newFakeRegistryForCommands(unitPrefix, len(r.units), false) - - c := createTestContext(t, append([]string{"stop", "--no-block"}, r.units...)...) + cAPI = newFakeRegistryForCommands(unitPrefix, len(r.units), false) wg.Add(2) go func() { defer wg.Done() - doStopUnits(t, r, errchan, cAPI, c) + doStopUnits(t, r, errchan) }() go func() { defer wg.Done() - doStopUnits(t, r, errchan, cAPI, c) + doStopUnits(t, r, errchan) }() go func() { diff --git a/fleetctl/submit_test.go b/fleetctl/submit_test.go index 04c937011..069f05bd2 100644 --- a/fleetctl/submit_test.go +++ b/fleetctl/submit_test.go @@ -19,13 +19,10 @@ import ( "strings" "sync" "testing" - - "github.com/coreos/fleet/client" ) -func doSubmitUnits(t *testing.T, r commandTestResults, errchan chan error, cAPI client.API) { - c := createTestContext(t, append([]string{"submit"}, r.units...)...) - exit := runSubmitUnits(c, cAPI) +func doSubmitUnits(t *testing.T, r commandTestResults, errchan chan error) { + exit := runSubmitUnit(cmdSubmit, r.units) if exit != r.expectedExit { errchan <- fmt.Errorf("%s: expected exit code %d but received %d", r.description, r.expectedExit, exit) return @@ -70,12 +67,12 @@ func runSubmitUnitsTests(t *testing.T, unitPrefix string, results []commandTestR unitsCount = len(r.units) } - cAPI := newFakeRegistryForCommands(unitPrefix, unitsCount, template) + cAPI = newFakeRegistryForCommands(unitPrefix, unitsCount, template) wg.Add(1) go func() { defer wg.Done() - doSubmitUnits(t, r, errchan, cAPI) + doSubmitUnits(t, r, errchan) }() go func() { @@ -91,6 +88,10 @@ func runSubmitUnitsTests(t *testing.T, unitPrefix string, results []commandTestR func TestRunSubmitUnits(t *testing.T) { unitPrefix := "submit" + oldNoBlock := sharedFlags.NoBlock + defer func() { + sharedFlags.NoBlock = oldNoBlock + }() results := []commandTestResults{ { @@ -153,6 +154,7 @@ func TestRunSubmitUnits(t *testing.T) { }, } + sharedFlags.NoBlock = true runSubmitUnitsTests(t, unitPrefix, results, false) runSubmitUnitsTests(t, unitPrefix, templateResults, true) } diff --git a/fleetctl/unload_test.go b/fleetctl/unload_test.go index 67f0bdad8..456a77ed9 100644 --- a/fleetctl/unload_test.go +++ b/fleetctl/unload_test.go @@ -19,14 +19,12 @@ import ( "sync" "testing" - "github.com/codegangsta/cli" - - "github.com/coreos/fleet/client" "github.com/coreos/fleet/job" ) -func doUnloadUnits(t *testing.T, r commandTestResults, errchan chan error, cAPI client.API, c *cli.Context) { - exit := runUnloadUnit(c, cAPI) +func doUnloadUnits(t *testing.T, r commandTestResults, errchan chan error) { + sharedFlags.NoBlock = true + exit := runUnloadUnit(cmdUnload, r.units) if exit != r.expectedExit { errchan <- fmt.Errorf("%s: expected exit code %d but received %d", r.description, r.expectedExit, exit) return @@ -48,6 +46,10 @@ func doUnloadUnits(t *testing.T, r commandTestResults, errchan chan error, cAPI func TestRunUnloadUnits(t *testing.T) { unitPrefix := "unload" + oldNoBlock := sharedFlags.NoBlock + defer func() { + sharedFlags.NoBlock = oldNoBlock + }() results := []commandTestResults{ { @@ -76,18 +78,16 @@ func TestRunUnloadUnits(t *testing.T) { var wg sync.WaitGroup errchan := make(chan error) - cAPI := newFakeRegistryForCommands(unitPrefix, len(r.units), false) - - c := createTestContext(t, append([]string{"unload", "--no-block"}, r.units...)...) + cAPI = newFakeRegistryForCommands(unitPrefix, len(r.units), false) wg.Add(2) go func() { defer wg.Done() - doUnloadUnits(t, r, errchan, cAPI, c) + doUnloadUnits(t, r, errchan) }() go func() { defer wg.Done() - doUnloadUnits(t, r, errchan, cAPI, c) + doUnloadUnits(t, r, errchan) }() go func() { From 235875e85f4eaeaac9ca56d742eeca4b60fcd0e3 Mon Sep 17 00:00:00 2001 From: Dongsu Park Date: Fri, 20 May 2016 09:44:51 +0200 Subject: [PATCH 6/6] functional: run correct commands for fleetctl help * Do not compare output of help messages, to avoid occasional failures. As cobra sometimes prints out a different help message, it causes functional test TestClientHelpFlag to fail. * Run "fleetctl version" instead of "fleetctl --version". * Run "fleetctl help" instead of "fleetctl" to get help message. --- functional/fleetctl_test.go | 11 +++-------- 1 file changed, 3 insertions(+), 8 deletions(-) diff --git a/functional/fleetctl_test.go b/functional/fleetctl_test.go index 569b7fd9c..d5f5e2afc 100644 --- a/functional/fleetctl_test.go +++ b/functional/fleetctl_test.go @@ -24,7 +24,7 @@ import ( ) func TestClientVersionFlag(t *testing.T) { - stdout, _, err := util.RunFleetctl("--version") + stdout, _, err := util.RunFleetctl("version") if err != nil { t.Fatalf("Unexpected error while executing fleetctl: %v", err) } @@ -35,7 +35,7 @@ func TestClientVersionFlag(t *testing.T) { } func TestClientVersionHelpOutput(t *testing.T) { - stdout, _, err := util.RunFleetctl() + stdout, _, err := util.RunFleetctl("help") if err != nil { t.Fatalf("Unexpected error while executing fleetctl: %v", err) } @@ -47,7 +47,7 @@ func TestClientVersionHelpOutput(t *testing.T) { func TestClientHelpFlag(t *testing.T) { var err error - var fixture, stdout, stderr string + var stdout, stderr string for i, tt := range []string{"--help", "-h", "help", ""} { if tt == "" { stdout, stderr, err = util.RunFleetctl() @@ -65,12 +65,7 @@ func TestClientHelpFlag(t *testing.T) { if len(stdout) == 0 { t.Fatalf("case 0: initial case has no help output") } - fixture = stdout continue } - - if stdout != fixture { - t.Errorf("case %d: stdout:\n%s\n\ndiffers from stdout of case 0:\n%s", i, stdout, fixture) - } } }