Correct pattern for exiting a command with a non zero return code

[tomqwpl]

I'm trying to establish what the correct pattern is for exiting a command with a non zero return code.

I can use RunE, but the normal effect of that is that the "usage" is printed out, since there's no distinction between an error from validating the args (where you would want usage to result) and an error from the operation of your command. You can SilenceUsage, but then you get no usage help on invalid args either, so that doesn't feel like the right way.

The examples generated by the CLI all use Run instead of RunE. The implication would appear to be that I have to manually os.Exit(1) if I want my command to "fail" and return a non zero return code. But that feels wrong, it's going to skip all of the post run actions etc.

Looking at a couple of examples, it seems like managing an exit code outside of cobra seems to be a solution used in a few places, so letting the command run to completion and then once cobra has returned calling os.Exit() with the value that's stored in some global variable somewhere.

What's the idiomatic usage here?

Thanks

[tomqwpl]

This almost gives me what I want:

var rootCmd = &cobra.Command{
	SilenceErrors:     true,
	SilenceUsage:      true,
}

func init() {
	rootCmd.SetFlagErrorFunc(func(c *cobra.Command, err error) error {
		return fmt.Errorf("%w\n\n%s", err, c.UsageString())
	})
}

func main() {
	err := rootCmd.Execute()
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
}

The SetFlagErrorFunc allows a hook when the error is caused by bad flags, but that doesn't get fired for invalid arguments other than flags (so validation done by the "Args" field in Command). Then use RunE, so you can return an error from the command and it will cause a non zero return code.

This has always somewhat surprised me in cobra. I'd have thought that the normal desired behaviour would be "invalid flags or args or command name, print error then usage, errors from the command, just print error". I've always slightly struggled to get that behaviour.

[nirs]

I'm using Run: and terminate on errors with log.Fatal() or os.Exit(). If the error is not a usage error, why print usage messages?

[abitrolly]

Let me analyze the error.

When cobra command returns an error, cobra prints help message.

package main

import (
	"errors"
	"os"

	"github.com/spf13/cobra"
)

var ErrorExit = errors.New("ErrorExit")

func main() {
	rootCmd := &cobra.Command{
		RunE: func(cmd *cobra.Command, ards []string) error {
			return ErrorExit
		},
	}
	if err := rootCmd.Execute(); err != nil {
		if err == ErrorExit {
			os.Exit(1)
		}
	}
}

Error: ErrorExit
Usage:
   [flags]

Flags:
  -h, --help   help for this command

exit status 1

[abitrolly]

Undocumented SilenceUsage changes the behavior.

https://go.dev/play/p/1oR9hP8Ix42

Error: ErrorExit

With and without SilenceUsage, if rootCmd returns nil, no usage is printed.

To force print usage, need to return pflag.ErrHelp.

[guettli]

I use that pattern now:

func main() {
	subCmd := cobra.Command{
		Use:          "my-sub-command",
		Short:        "....",
		SilenceUsage: true,
		RunE: func(_ *cobra.Command, _ []string) error {
			return subCommand()
		},
	}
	rootCmd := cobra.Command{
		Use:   "my-command",
		Short: "My Command",
	}
	rootCmd.AddCommand(&subCmd)
	err := rootCmd.Execute()
	if err != nil {
		os.Exit(1)
	}
}

Ideas how to improve that are welcome.

[xStrom]

I can use RunE, but the normal effect of that is that the "usage" is printed out, since there's no distinction between an error from validating the args (where you would want usage to result) and an error from the operation of your command. You can SilenceUsage, but then you get no usage help on invalid args either, so that doesn't feel like the right way.

The key to unlocking this behavior is understanding that SilenceUsage is not read until the usage printing time comes. Which means that you can set its value way later than you imagined.

var fooCmd = &cobra.Command{
	Use:   "foo BAR",
	Short: "Foo a bar.",
	Args: func(cmd *cobra.Command, args []string) error {
		if len(args) == 0 {
                        // cmd.SilenceUsage == false => usage is printed
			return errors.New("no bar provided")
		}
		return nil
	},
	RunE: func(cmd *cobra.Command, args []string) error {
		if args[0] == "zoo" {
                        // cmd.SilenceUsage == false => usage is printed
			return errors.New("no zoo allowed")
		}
                cmd.SilenceUsage = true // any errors returned after this point don't print usage
                if err := process(args[0]); err != nil {
                    // cmd.SilenceUsage == true => usage is NOT printed
                    return errors.New("failed to process bar");
                }
		fmt.Println("Bar processed!")
		return nil
	},
}