pass context through cmd and use RunE instead of Run

Signed-off-by: Tim Ramlot <[email protected]>

Author: inteon

cmd/cmd.go

@@ -47,6 +47,7 @@ func NewCertManagerCtlCommand(ctx context.Context, in io.Reader, out, err io.Wri
 			return logf.ValidateAndApply(logOptions)
 		},
 		SilenceErrors: true, // Errors are already logged when calling cmd.Execute()
+		SilenceUsage:  true, // Don't print usage when an error occurs
 	}
 	cmds.SetUsageTemplate(usageTemplate())
 

go.mod

@@ -65,6 +65,7 @@ require (
 	github.com/fatih/camelcase v1.0.0 // indirect
 	github.com/fatih/color v1.15.0 // indirect
 	github.com/felixge/httpsnoop v1.0.4 // indirect
+	github.com/fsnotify/fsnotify v1.7.0 // indirect
 	github.com/go-asn1-ber/asn1-ber v1.5.5 // indirect
 	github.com/go-errors/errors v1.4.2 // indirect
 	github.com/go-gorp/gorp/v3 v3.1.0 // indirect

internal/util/context.go

@@ -17,6 +17,8 @@ limitations under the License.
 package util
 
 import (
+	"context"
+	"fmt"
 	"os"
 	"os/signal"
 	"syscall"
@@ -40,35 +42,35 @@ const (
 )
 
 // SetupExitHandler:
-// A stop channel is returned which is closed on receiving a shutdown signal (SIGTERM
+// A context is returned which is canceled on receiving a shutdown signal (SIGTERM
 // or SIGINT). If a second signal is caught, the program is terminated directly with
 // exit code 130.
 // SetupExitHandler also returns an exit function, this exit function calls os.Exit(...)
 // if there is a exit code in the errorExitCodeChannel.
 // The errorExitCodeChannel receives exit codes when SetExitCode is called or when
 // a shutdown signal is received (only if exitBehavior is AlwaysErrCode).
-func SetupExitHandler(exitBehavior ExitBehavior) (<-chan struct{}, func()) {
+func SetupExitHandler(parentCtx context.Context, exitBehavior ExitBehavior) (context.Context, func()) {
 	close(onlyOneSignalHandler) // panics when called twice
 
-	stop := make(chan struct{})
+	ctx, cancel := context.WithCancelCause(parentCtx)
 	c := make(chan os.Signal, 2)
 	signal.Notify(c, shutdownSignals...)
 	go func() {
-		// first signal. Close stop chan and pass exit code to exitCodeChannel.
-		exitCode := 128 + int((<-c).(syscall.Signal))
+		// first signal. Cancel context and pass exit code to errorExitCodeChannel.
+		signalInt := int((<-c).(syscall.Signal))
 		if exitBehavior == AlwaysErrCode {
-			errorExitCodeChannel <- exitCode
+			errorExitCodeChannel <- signalInt
 		}
-		close(stop)
+		cancel(fmt.Errorf("received signal %d", signalInt))
 		// second signal. Exit directly.
 		<-c
 		os.Exit(130)
 	}()
 
-	return stop, func() {
+	return ctx, func() {
 		select {
-		case signal := <-errorExitCodeChannel:
-			os.Exit(signal)
+		case signalInt := <-errorExitCodeChannel:
+			os.Exit(128 + signalInt)
 		default:
 			// Do not exit, there are no exit codes in the channel,
 			// so just continue and let the main function go out of

internal/util/signal.go

@@ -24,18 +24,21 @@ import (
 	"strings"
 
 	cmdutil "k8s.io/kubectl/pkg/cmd/util"
+	ctrl "sigs.k8s.io/controller-runtime"
 
 	logf "github.com/cert-manager/cert-manager/pkg/logs"
 	ctlcmd "github.com/cert-manager/cmctl/v2/cmd"
 	"github.com/cert-manager/cmctl/v2/internal/util"
 )
 
 func main() {
-	stopCh, exit := util.SetupExitHandler(util.AlwaysErrCode)
+	ctx, exit := util.SetupExitHandler(context.Background(), util.AlwaysErrCode)
 	defer exit() // This function might call os.Exit, so defer last
 
 	logf.InitLogs()
 	defer logf.FlushLogs()
+	ctrl.SetLogger(logf.Log)
+	ctx = logf.NewContext(ctx, logf.Log, "cmctl")
 
 	// In cmctl, we are using cmdutil.CheckErr, a kubectl utility function that creates human readable
 	// error messages from errors. By default, this function will call os.Exit(1) if it receives an error.
@@ -56,10 +59,9 @@ func main() {
 		runtime.Goexit() // Do soft exit (handle all defers, that should set correct exit code)
 	})
 
-	ctx := util.ContextWithStopCh(context.Background(), stopCh)
 	cmd := ctlcmd.NewCertManagerCtlCommand(ctx, os.Stdin, os.Stdout, os.Stderr)
 
-	if err := cmd.Execute(); err != nil {
+	if err := cmd.ExecuteContext(ctx); err != nil {
 		cmdutil.CheckErr(err)
 	}
 }

main.go

@@ -24,7 +24,6 @@ import (
 	"github.com/spf13/cobra"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/cli-runtime/pkg/genericclioptions"
-	cmdutil "k8s.io/kubectl/pkg/cmd/util"
 	"k8s.io/kubectl/pkg/util/i18n"
 	"k8s.io/kubectl/pkg/util/templates"
 
@@ -68,18 +67,20 @@ func newOptions(ioStreams genericclioptions.IOStreams) *Options {
 	}
 }
 
-func NewCmdApprove(ctx context.Context, ioStreams genericclioptions.IOStreams) *cobra.Command {
+func NewCmdApprove(setupCtx context.Context, ioStreams genericclioptions.IOStreams) *cobra.Command {
 	o := newOptions(ioStreams)
 
 	cmd := &cobra.Command{
 		Use:               "approve",
 		Short:             "Approve a CertificateRequest",
 		Long:              `Mark a CertificateRequest as Approved, so it may be signed by a configured Issuer.`,
 		Example:           example,
-		ValidArgsFunction: factory.ValidArgsListCertificateRequests(ctx, &o.Factory),
-		Run: func(cmd *cobra.Command, args []string) {
-			cmdutil.CheckErr(o.Validate(args))
-			cmdutil.CheckErr(o.Run(ctx, args))
+		ValidArgsFunction: factory.ValidArgsListCertificateRequests(&o.Factory),
+		PreRunE: func(cmd *cobra.Command, args []string) error {
+			return o.Validate(args)
+		},
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return o.Run(cmd.Context(), args)
 		},
 	}
 
@@ -88,7 +89,7 @@ func NewCmdApprove(ctx context.Context, ioStreams genericclioptions.IOStreams) *
 	cmd.Flags().StringVar(&o.Message, "message", fmt.Sprintf("manually approved by %q", build.Name()),
 		"The message to give as to why this CertificateRequest was approved.")
 
-	o.Factory = factory.New(ctx, cmd)
+	o.Factory = factory.New(cmd)
 
 	return cmd
 }

pkg/approve/approve.go

@@ -26,7 +26,6 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/util/wait"
 	"k8s.io/cli-runtime/pkg/genericclioptions"
-	cmdutil "k8s.io/kubectl/pkg/cmd/util"
 	"k8s.io/kubectl/pkg/util/i18n"
 	"k8s.io/kubectl/pkg/util/templates"
 
@@ -83,22 +82,24 @@ func (o *Options) Complete() error {
 }
 
 // NewCmdCheckApi returns a cobra command for checking creating cert-manager resources against the K8S API server
-func NewCmdCheckApi(ctx context.Context, ioStreams genericclioptions.IOStreams) *cobra.Command {
+func NewCmdCheckApi(setupCtx context.Context, ioStreams genericclioptions.IOStreams) *cobra.Command {
 	o := NewOptions(ioStreams)
 
 	cmd := &cobra.Command{
 		Use:   "api",
 		Short: "Check if the cert-manager API is ready",
 		Long:  checkApiDesc,
-		Run: func(cmd *cobra.Command, args []string) {
-			cmdutil.CheckErr(o.Complete())
-			cmdutil.CheckErr(o.Run(ctx))
+		PreRunE: func(cmd *cobra.Command, args []string) error {
+			return o.Complete()
+		},
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return o.Run(cmd.Context())
 		},
 	}
 	cmd.Flags().DurationVar(&o.Wait, "wait", 0, "Wait until the cert-manager API is ready (default 0s = poll once)")
 	cmd.Flags().DurationVar(&o.Interval, "interval", 5*time.Second, "Time between checks when waiting, must include unit, e.g. 1m or 10m")
 
-	o.Factory = factory.New(ctx, cmd)
+	o.Factory = factory.New(cmd)
 
 	return cmd
 }

pkg/check/api/api.go

@@ -26,9 +26,9 @@ import (
 )
 
 // NewCmdCheck returns a cobra command for checking cert-manager components.
-func NewCmdCheck(ctx context.Context, ioStreams genericclioptions.IOStreams) *cobra.Command {
+func NewCmdCheck(setupCtx context.Context, ioStreams genericclioptions.IOStreams) *cobra.Command {
 	cmds := NewCmdCreateBare()
-	cmds.AddCommand(api.NewCmdCheckApi(ctx, ioStreams))
+	cmds.AddCommand(api.NewCmdCheckApi(setupCtx, ioStreams))
 
 	return cmds
 }

pkg/check/check.go

@@ -19,7 +19,6 @@ package completion
 import (
 	"github.com/spf13/cobra"
 	"k8s.io/cli-runtime/pkg/genericclioptions"
-	"k8s.io/kubectl/pkg/cmd/util"
 
 	"github.com/cert-manager/cmctl/v2/pkg/build"
 )
@@ -39,8 +38,8 @@ Bash:
   $ {{.BuildName}} completion bash > /usr/local/etc/bash_completion.d/{{.BuildName}}
 `),
 		DisableFlagsInUseLine: true,
-		Run: func(cmd *cobra.Command, args []string) {
-			util.CheckErr(cmd.Root().GenBashCompletion(ioStreams.Out))
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return cmd.Root().GenBashCompletion(ioStreams.Out)
 		},
 	}
 }

pkg/completion/bash.go

@@ -23,7 +23,7 @@ import (
 	"k8s.io/cli-runtime/pkg/genericclioptions"
 )
 
-func NewCmdCompletion(ctx context.Context, ioStreams genericclioptions.IOStreams) *cobra.Command {
+func NewCmdCompletion(setupCtx context.Context, ioStreams genericclioptions.IOStreams) *cobra.Command {
 	cmds := &cobra.Command{
 		Use:   "completion",
 		Short: "Generate completion scripts for the cert-manager CLI",