Refactor to use Cobra

Author: splittingred

CHANGELOG.md

@@ -2,8 +2,9 @@ The changelog for Bonvoy
 
 ## Pending Release
 
-* Add `server-info` command to display information about the Envoy sidecar
-* Add `log-level` command to set Envoy's log level
+* Restructured to use cobra cli library rather than flag
+* Add `server info` command to display information about the Envoy sidecar
+* Add `log level` command to set Envoy's log level
 * Restructure for better memory usage and a more closed API
 
 ## 0.0.1

README.md

@@ -19,5 +19,17 @@ bonvoy listeners auth-grpc
 ### Show all Expired Certificates
 
 ```bash
-bonvoy certs-expired auth-grpc
+bonvoy certificates expired auth-grpc
+```
+
+### Show Server Info
+
+```bash
+bonvoy server info auth-grpc
+```
+
+### Set Envoy Log Level
+
+```bash
+bonvoy log level auth-grpc -l debug
 ```

bonvoy.go

@@ -3,37 +3,37 @@ package main
 import (
 	"bonvoy/commands"
 	"bonvoy/config"
-	"fmt"
 	"os"
 )
 
-func root(args[] string) error {
-	var cmds = commands.All()
-	subcommand := os.Args[1]
-
-	for _, cmd := range cmds {
-		if cmd.Name() == subcommand {
-			var err = cmd.Init(os.Args[2:])
-			if err != nil {
-				panic(err)
-			}
-			return cmd.Run()
-		}
-	}
-	return fmt.Errorf("Unknown subcommand: %s", subcommand)
-}
+//func root(args[] string) error {
+//	var cmds = commands.All()
+//	subcommand := os.Args[1]
+//
+//	for _, cmd := range cmds {
+//		if cmd.Name() == subcommand {
+//			var err = cmd.Init(os.Args[2:])
+//			if err != nil {
+//				panic(err)
+//			}
+//			return cmd.Run()
+//		}
+//	}
+//	return fmt.Errorf("Unknown subcommand: %s", subcommand)
+//}
 
 func main() {
 	_ = os.Setenv("DOCKER_API_VERSION", "1.39")
 	config.Load()
-	if len(os.Args) < 2 {
-		fmt.Println("USAGE: bonvoy" +
-			"\n\tversion - Display bonvoy version" +
-			"\n\tlog-level [service] (level) - Set log level for a sidecar" +
-			"\n\tcerts-expired - Display expired certificates compared to Consul agent for a sidecar" +
-			"\n\tlisteners [service] - Display all listeners for sidecar")
-	} else if err := root(os.Args[1:]); err != nil {
-		fmt.Println(err)
-		os.Exit(1)
-	}
+	commands.Init()
+	//if len(os.Args) < 2 {
+	//	fmt.Println("USAGE: bonvoy" +
+	//		"\n\tversion - Display bonvoy version" +
+	//		"\n\tlog-level [service] (level) - Set log level for a sidecar" +
+	//		"\n\tcerts-expired - Display expired certificates compared to Consul agent for a sidecar" +
+	//		"\n\tlisteners [service] - Display all listeners for sidecar")
+	//} else if err := root(os.Args[1:]); err != nil {
+	//	fmt.Println(err)
+	//	os.Exit(1)
+	//}
 }

commands/certificates.go

@@ -3,60 +3,52 @@ package commands
 import (
 	"bonvoy/consul"
 	"bonvoy/envoy"
-	"flag"
 	"fmt"
+	"github.com/spf13/cobra"
 	"strings"
 )
 
-type ExpiredCertificatesCommand struct {
-	fs *flag.FlagSet
-	consul consul.Client
-	name string
+type ExpiredCertificatesController struct {
+	ServiceName string
+	Consul consul.Client
 }
 
-func BuildExpiredCertificatesCommand() *ExpiredCertificatesCommand {
-	gc := &ExpiredCertificatesCommand{
-		fs: flag.NewFlagSet("certs-expired", flag.ContinueOnError),
-		consul: consul.NewClient(),
-	}
-	gc.fs.Arg(0)
-	return gc
-}
-
-func (g *ExpiredCertificatesCommand) Name() string {
-	return g.fs.Name()
-}
-
-func (g *ExpiredCertificatesCommand) Init(args []string) error {
-	return g.fs.Parse(args)
+func BuildExpiredCertificatesController(rootCmd *cobra.Command) {
+	rootCmd.AddCommand(&cobra.Command{
+		Use: "certificates expired",
+		Short: "Show all expired certificates",
+		Long:  `Display all expired sidecar certificates as compared to the local Consul agent`,
+		Args: cobra.MinimumNArgs(2),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			controller := ExpiredCertificatesController{
+				ServiceName: args[1],
+				Consul: consul.NewClient(),
+			}
+			return controller.Run()
+		},
+	})
 }
 
-func (g *ExpiredCertificatesCommand) Run() error {
-	var name = g.name
-	if name == "" {
-		name = g.fs.Arg(0)
-	}
-
-	e, err := envoy.NewFromServiceName(name)
+func (c *ExpiredCertificatesController) Run() error {
+	e, err := envoy.NewFromServiceName(c.ServiceName)
 	if err != nil {
 		return err
 	}
 	data := e.Certificates().Get()
 
 	for _, certs := range data.Certificates {
-		for _, c := range certs.CertificateChain {
-			a := strings.Split(c.SubjectAltNames[0].Uri, "/")
+		for _, cert := range certs.CertificateChain {
+			a := strings.Split(cert.SubjectAltNames[0].Uri, "/")
 			svc := a[len(a)-1]
-			leaf := g.consul.Agent().GetConnectLeafCaCertificate(svc)
+			leaf := c.Consul.Agent().GetConnectLeafCaCertificate(svc)
 
-			if c.ExpirationTime != leaf.ValidBefore {
+			if cert.ExpirationTime != leaf.ValidBefore {
 				fmt.Println(svc)
 				fmt.Println("  Envoy Process ID:", e.Pid)
-				fmt.Printf("  Envoy Certificate Expiry: %s (%s days)\n", c.ExpirationTime, c.DaysUntilExpiration)
+				fmt.Printf("  Envoy Certificate Expiry: %s (%s days)\n", cert.ExpirationTime, cert.DaysUntilExpiration)
 				fmt.Println("  Consul Agent Certificate Expiry: ", leaf.ValidBefore)
 			}
 		}
 	}
-
 	return nil
-}
+}

commands/listeners.go

@@ -4,47 +4,42 @@ import (
 	"bonvoy/envoy"
 	"flag"
 	"fmt"
+	"github.com/spf13/cobra"
 )
 
-type ListenersCommand struct {
-	fs *flag.FlagSet
-	name string
-}
-
-// ListenersCommand
-func BuildListeners() *ListenersCommand {
-	gc := &ListenersCommand{
-		fs: flag.NewFlagSet("listeners", flag.ContinueOnError),
-	}
-	gc.fs.Arg(0)
-	gc.fs.StringVar(&gc.name, "service", "", "name of the service whose sidecar to enter")
-	return gc
-}
-
-func (g *ListenersCommand) Name() string {
-	return g.fs.Name()
+type ListenersController struct {
+	ServiceName string
 }
 
-func (g *ListenersCommand) Init(args []string) error {
-	return g.fs.Parse(args)
+func BuildListenersCommand(rootCmd *cobra.Command) {
+	rootCmd.AddCommand(&cobra.Command{
+		Use: "listeners",
+		Short: "Show Envoy listeners",
+		Long:  `Display all registered Envoy sidecar listeners`,
+		Args: cobra.MinimumNArgs(2),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			controller := ListenersController{
+				ServiceName: args[1],
+			}
+			return controller.Run()
+		},
+	})
 }
 
-func (g *ListenersCommand) Run() error {
-	var name = g.name
-	if name == "" {
-		name = g.fs.Arg(0)
-	}
-
-	e, err := envoy.NewFromServiceName(name)
+func (s *ListenersController) Run() error {
+	e, err := envoy.NewFromServiceName(s.ServiceName)
 	if err != nil {
 		return err
 	}
 	listeners := e.Listeners().Get()
-
 	fmt.Println("LISTENERS:")
 	fmt.Println("----------------------------------------------------------------------")
 	for _, listener := range listeners {
 		fmt.Printf("%s: %s\n", listener.Name, listener.TargetAddress)
 	}
 	return nil
 }
+type ListenersCommand struct {
+	fs *flag.FlagSet
+	name string
+}

commands/logging.go

@@ -2,65 +2,57 @@ package commands
 
 import (
 	"bonvoy/envoy"
-	"flag"
 	"fmt"
 	"github.com/manifoldco/promptui"
+	"github.com/spf13/cobra"
 )
 
-type SetLogLevelCommand struct {
-	fs *flag.FlagSet
-	name string
-	level string
-}
-
-// ListenersCommand
-func BuildSetLogLevelCommand() *SetLogLevelCommand {
-	gc := &SetLogLevelCommand{
-		fs: flag.NewFlagSet("log-level", flag.ContinueOnError),
-	}
-	gc.fs.StringVar(&gc.name, "service", "", "name of the service sidecar to set logging for")
-	gc.fs.StringVar(&gc.level, "level", "", "Value to set logging to. Must be one of debug/info/warning/error")
-	return gc
-}
+var (
+	logLevel string
+)
 
-func (g *SetLogLevelCommand) Name() string {
-	return g.fs.Name()
+type SetLogLevelController struct {
+	ServiceName string
 }
 
-func (g *SetLogLevelCommand) Init(args []string) error {
-	return g.fs.Parse(args)
+func BuildSetLogLevelCommand(rootCmd *cobra.Command) {
+	cmd := &cobra.Command{
+		Use: "log level",
+		Short: "Set Envoy log level",
+		Long:  `Set the Envoy sidecar log level`,
+		Args: cobra.MinimumNArgs(2),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			controller := SetLogLevelController{
+				ServiceName: args[1],
+			}
+			return controller.Run()
+		},
+	}
+	cmd.Flags().StringVarP(&logLevel, "level", "l", "", "Desired log level (debug/info/warning/error")
+	rootCmd.AddCommand(cmd)
 }
 
-func (g *SetLogLevelCommand) Run() error {
-	var name = g.name
-	if name == "" {
-		name = g.fs.Arg(0)
+func (c *SetLogLevelController) Run() error {
+	if logLevel == "" {
+		logLevel = c.SelectLogLevel()
 	}
-	var level = g.level
-	if level == "" {
-		level = g.fs.Arg(1)
-		if level == "" {
-			level = g.SelectLogLevel()
-		}
-	}
-
-	e, err := envoy.NewFromServiceName(name)
+	e, err := envoy.NewFromServiceName(c.ServiceName)
 	if err != nil {
 		return err
 	}
-	e.Logging().SetLevel(level)
+	e.Logging().SetLevel(logLevel)
 	return nil
 }
 
-func (g *SetLogLevelCommand) SelectLogLevel() string {
+func (c *SetLogLevelController) SelectLogLevel() string {
 	prompt := promptui.Select{
 		Label: "Please Select a Log Level",
 		Items: []string{"debug", "info", "warning", "error"},
 	}
 	_, desired, err := prompt.Run()
 	if err != nil {
 		fmt.Printf("Prompt failed %v\n", err)
-		panic(err)
+		return "info"
 	}
 	return desired
 }