kuma

1
package cmd
2

3
import (
4
	"fmt"
5
	"os"
6
	"path/filepath"
7

8
	"github.com/spf13/cobra"
9

10
	kuma_cmd "github.com/kumahq/kuma/pkg/cmd"
11
	"github.com/kumahq/kuma/pkg/cmd/version"
12
	"github.com/kumahq/kuma/pkg/core"
13
	kuma_log "github.com/kumahq/kuma/pkg/log"
14
)
15

16
var dataplaneLog = core.Log.WithName("kuma-dp")
17

18
// NewRootCmd represents the base command when called without any subcommands.
19
func NewRootCmd(opts kuma_cmd.RunCmdOpts, rootCtx *RootContext) *cobra.Command {
20
	args := struct {
21
		logLevel   string
22
		outputPath string
23
		maxSize    int
24
		maxBackups int
25
		maxAge     int
26
	}{}
27
	cmd := &cobra.Command{
28
		Use:   "kuma-dp",
29
		Short: "Dataplane manager for Envoy-based Service Mesh",
30
		Long:  `Dataplane manager for Envoy-based Service Mesh.`,
31
		PersistentPreRunE: func(cmd *cobra.Command, _ []string) error {
32
			level, err := kuma_log.ParseLogLevel(args.logLevel)
33
			if err != nil {
34
				return err
35
			}
36

37
			if args.outputPath != "" {
38
				output, err := filepath.Abs(args.outputPath)
39
				if err != nil {
40
					return err
41
				}
42

43
				fmt.Printf("%s: logs will be stored in %q\n", "kuma-dp", output)
44
				core.SetLogger(core.NewLoggerWithRotation(level, output, args.maxSize, args.maxBackups, args.maxAge))
45
			} else {
46
				core.SetLogger(core.NewLogger(level))
47
			}
48
			rootCtx.LogLevel = level
49

50
			// once command line flags have been parsed,
51
			// avoid printing usage instructions
52
			cmd.SilenceUsage = true
53

54
			return nil
55
		},
56
	}
57

58
	cmd.SetOut(os.Stdout)
59

60
	// root flags
61
	cmd.PersistentFlags().StringVar(&args.logLevel, "log-level", kuma_log.InfoLevel.String(), kuma_cmd.UsageOptions("log level", kuma_log.OffLevel, kuma_log.InfoLevel, kuma_log.DebugLevel))
62
	cmd.PersistentFlags().StringVar(&args.outputPath, "log-output-path", args.outputPath, "path to the file that will be filled with logs. Example: if we set it to /tmp/kuma.log then after the file is rotated we will have /tmp/kuma-2021-06-07T09-15-18.265.log")
63
	cmd.PersistentFlags().IntVar(&args.maxBackups, "log-max-retained-files", 1000, "maximum number of the old log files to retain")
64
	cmd.PersistentFlags().IntVar(&args.maxSize, "log-max-size", 100, "maximum size in megabytes of a log file before it gets rotated")
65
	cmd.PersistentFlags().IntVar(&args.maxAge, "log-max-age", 30, "maximum number of days to retain old log files based on the timestamp encoded in their filename")
66

67
	// sub-commands
68
	cmd.AddCommand(newRunCmd(opts, rootCtx))
69
	cmd.AddCommand(version.NewVersionCmd())
70
	cmd.AddCommand(newWaitCmd())
71

72
	return cmd
73
}
74

75
func DefaultRootCmd() *cobra.Command {
76
	return NewRootCmd(kuma_cmd.DefaultRunCmdOpts, DefaultRootContext())
77
}
78

79
// Execute adds all child commands to the root command and sets flags appropriately.
80
// This is called by main.main(). It only needs to happen once to the rootCmd.
81
func Execute() {
82
	if err := DefaultRootCmd().Execute(); err != nil {
83
		os.Exit(1)
84
	}
85
}
86