Merge pull request #2 from grpc-ecosystem/copy

All code in grpcdebug

cmd/config/config.go

@@ -0,0 +1,183 @@
+package config
+
+import (
+ "errors"
+ "fmt"
+ "io/ioutil"
+ "log"
+ "os"
+ "path"
+ "regexp"
+ "runtime"
+ "strings"
+
+ "github.com/grpc-ecosystem/grpcdebug/cmd/verbose"
+)
+
+// SecurityType is the enum type of available security modes
+type SecurityType int
+
+const (
+ // TypeInsecure is the insecure security mode and it is the default value
+ TypeInsecure SecurityType = iota
+ // TypeTls is the TLS security mode, which requires caller to provide
+ // credentials to connect to peer
+ TypeTls
+)
+
+// The environment variable name of getting the server configs
+const grpcdebugServerConfigEnvName = "GRPCDEBUG_CONFIG"
+
+func (e SecurityType) String() string {
+ switch e {
+ case TypeInsecure:
+ return "Insecure"
+ case TypeTls:
+ return "TLS"
+ default:
+ return fmt.Sprintf("%d", int(e))
+ }
+}
+
+// ServerConfig is the configuration for how to connect to a target
+type ServerConfig struct {
+ Pattern string
+ RealAddress string
+ Security SecurityType
+ CredentialFile string
+ ServerNameOverride string
+}
+
+func parseServerPattern(x string) (string, error) {
+ var matcher = regexp.MustCompile(`^Server\s+?([A-Za-z0-9-_\.\*\?:]*)$`)
+ tokens := matcher.FindStringSubmatch(x)
+ if len(tokens) != 2 {
+ return "", fmt.Errorf("Invalid server pattern: %v", x)
+ }
+ return strings.TrimSpace(tokens[1]), nil
+}
+
+func parseServerOption(x string) (string, string, error) {
+ var matcher = regexp.MustCompile(`^(\w+?)\s+?(\S*)$`)
+ tokens := matcher.FindStringSubmatch(x)
+ if len(tokens) != 3 {
+ return "", "", fmt.Errorf("Invalid server option: %v", x)
+ }
+ return strings.TrimSpace(tokens[1]), strings.TrimSpace(tokens[2]), nil
+}
+
+func loadServerConfigsFromFile(path string) []ServerConfig {
+ file, err := os.Open(path)
+ if err != nil {
+ panic(err)
+ }
+ bytes, err := ioutil.ReadAll(file)
+ if err != nil {
+ panic(err)
+ }
+ lines := strings.Split(string(bytes), "\n")
+ var configs []ServerConfig
+ var current *ServerConfig
+ for i, line := range lines {
+ if strings.HasPrefix(line, "Server") {
+ pattern, err := parseServerPattern(line)
+ if err != nil {
+ log.Fatalf("Failed to parse config [%v:%d]: %v", path, i, err)
+ }
+ configs = append(configs, ServerConfig{Pattern: pattern})
+ current = &configs[len(configs)-1]
+ } else {
+ stem := strings.TrimSpace(line)
+ if stem == "" {
+ // Allow black lines, skip them
+ continue
+ }
+ key, value, err := parseServerOption(stem)
+ if err != nil {
+ log.Fatalf("Failed to parse config [%v:%d]: %v", path, i, err)
+ }
+ switch key {
+ case "RealAddress":
+ current.RealAddress = value
+ case "Security":
+ switch strings.ToLower(value) {
+ case "insecure":
+ current.Security = TypeInsecure
+ case "tls":
+ current.Security = TypeTls
+ default:
+ log.Fatalf("Unsupported security model: %v", value)
+ }
+ case "CredentialFile":
+ current.CredentialFile = value
+ case "ServerNameOverride":
+ current.ServerNameOverride = value
+ }
+ }
+ }
+ verbose.Debugf("Loaded server configs from %v: %v", path, configs)
+ return configs
+}
+
+func UserConfigDir() (string, error) {
+ var dir string
+ switch runtime.GOOS {
+ case "windows":
+ dir = os.Getenv("AppData")
+ if dir == "" {
+ return "", errors.New("%AppData% is not defined")
+ }
+
+ case "darwin", "ios":
+ dir = os.Getenv("HOME")
+ if dir == "" {
+ return "", errors.New("$HOME is not defined")
+ }
+ dir += "/Library/Application Support"
+
+ case "plan9":
+ dir = os.Getenv("home")
+ if dir == "" {
+ return "", errors.New("$home is not defined")
+ }
+ dir += "/lib"
+
+ default: // Unix
+ dir = os.Getenv("XDG_CONFIG_HOME")
+ if dir == "" {
+ dir = os.Getenv("HOME")
+ if dir == "" {
+ return "", errors.New("neither $XDG_CONFIG_HOME nor $HOME are defined")
+ }
+ dir += "/.config"
+ }
+ }
+ return dir, nil
+}
+
+func loadServerConfigs() []ServerConfig {
+ if value := os.Getenv(grpcdebugServerConfigEnvName); value != "" {
+ return loadServerConfigsFromFile(value)
+ }
+ // Try to load from work directory, if exists
+ if _, err := os.Stat("./grpcdebug_config"); err == nil {
+ return loadServerConfigsFromFile("./grpcdebug_config")
+ }
+ // Try to load from user config directory, if exists
+ dir, _ := UserConfigDir()
+ defaultUserConfig := path.Join(dir, "grpcdebug_config")
+ if _, err := os.Stat(defaultUserConfig); err == nil {
+ return loadServerConfigsFromFile(defaultUserConfig)
+ }
+ return nil
+}
+
+// GetServerConfig returns a connect configuration for the given target
+func GetServerConfig(target string) ServerConfig {
+ for _, config := range loadServerConfigs() {
+ if config.Pattern == target {
+ return config
+ }
+ }
+ return ServerConfig{RealAddress: target}
+}

cmd/health.go

@@ -0,0 +1,32 @@
+package cmd
+
+import (
+ "fmt"
+
+ "github.com/grpc-ecosystem/grpcdebug/cmd/transport"
+ "github.com/spf13/cobra"
+)
+
+var healthCmd = &cobra.Command{
+ Use: "health [service names]",
+ Short: "Check health status of the target service (default \"\").",
+ RunE: func(cmd *cobra.Command, args []string) error {
+ if len(args) == 0 {
+ fmt.Println(transport.GetHealthStatus(""))
+ return nil
+ }
+ for _, service := range args {
+ fmt.Fprintf(
+ w, "%v:\t%v\t\n",
+ service,
+ transport.GetHealthStatus(service),
+ )
+ }
+ w.Flush()
+ return nil
+ },
+}
+
+func init() {
+ rootCmd.AddCommand(healthCmd)
+}

cmd/root.go

@@ -0,0 +1,111 @@
+// Defines the root command and global flags
+
+package cmd
+
+import (
+ "fmt"
+ "log"
+ "os"
+ "text/tabwriter"
+
+ "github.com/grpc-ecosystem/grpcdebug/cmd/config"
+ "github.com/grpc-ecosystem/grpcdebug/cmd/transport"
+ "github.com/grpc-ecosystem/grpcdebug/cmd/verbose"
+
+ "github.com/spf13/cobra"
+)
+
+var verboseFlag, timestampFlag bool
+var address, security, credFile, serverNameOverride string
+
+// The table formater
+var w = tabwriter.NewWriter(os.Stdout, 10, 0, 3, ' ', 0)
+
+var rootUsageTemplate = `Usage:{{if .Runnable}}
+ {{.UseLine}}{{end}}{{if .HasAvailableSubCommands}}
+ grpcdebug <target address> [flags] {{ .CommandPath | ChildCommandPath }} <command>{{end}}{{if gt (len .Aliases) 0}}
+
+Aliases:
+ {{.NameAndAliases}}{{end}}{{if .HasExample}}
+
+Examples:
+{{.Example}}{{end}}{{if .HasAvailableSubCommands}}
+
+Available Commands:{{range .Commands}}{{if (or .IsAvailableCommand (eq .Name "help"))}}
+ {{rpad .Name .NamePadding }} {{.Short}}{{end}}{{end}}{{end}}{{if .HasAvailableLocalFlags}}
+
+Flags:
+{{.LocalFlags.FlagUsages | trimTrailingWhitespaces}}{{end}}{{if .HasAvailableInheritedFlags}}
+
+Global Flags:
+{{.InheritedFlags.FlagUsages | trimTrailingWhitespaces}}{{end}}{{if .HasHelpSubCommands}}
+
+Additional help topics:{{range .Commands}}{{if .IsAdditionalHelpTopicCommand}}
+ {{rpad .CommandPath .CommandPathPadding}} {{.Short}}{{end}}{{end}}{{end}}{{if .HasAvailableSubCommands}}
+
+Use "grpcdebug <target address> {{ .CommandPath | ChildCommandPath }} [command] --help" for more information about a command.{{end}}
+`
+
+var rootCmd = &cobra.Command{
+ Use: "grpcdebug",
+ Short: "grpcdebug is an gRPC service admin CLI",
+}
+
+func initConfig() {
+ if verboseFlag {
+ verbose.EnableDebugOutput()
+ }
+ c := config.GetServerConfig(address)
+ if credFile != "" {
+ c.CredentialFile = credFile
+ }
+ if serverNameOverride != "" {
+ c.ServerNameOverride = serverNameOverride
+ }
+ if security == "tls" {
+ c.Security = config.TypeTls
+ if c.CredentialFile == "" {
+ rootCmd.Usage()
+ log.Fatalf("Please specify credential file under [tls] mode.")
+ }
+ } else if security != "insecure" {
+ rootCmd.Usage()
+ log.Fatalf("Unrecognized security mode: %v", security)
+ }
+ transport.Connect(c)
+}
+
+// ChildCommandPath used in template
+func ChildCommandPath(path string) string {
+ if len(path) <= 10 {
+ return ""
+ }
+ return path[10:]
+}
+
+func init() {
+ cobra.AddTemplateFunc("ChildCommandPath", ChildCommandPath)
+ cobra.OnInitialize(initConfig)
+ rootCmd.SetUsageTemplate(rootUsageTemplate)
+
+ rootCmd.PersistentFlags().BoolVarP(&verboseFlag, "verbose", "v", false, "Print verbose information for debugging")
+ rootCmd.PersistentFlags().BoolVarP(&timestampFlag, "timestamp", "t", false, "Print timestamp as RFC3339 instead of human readable strings")
+ rootCmd.PersistentFlags().StringVar(&security, "security", "insecure", "Defines the type of credentials to use [tls, google-default, insecure]")
+ rootCmd.PersistentFlags().StringVar(&credFile, "credential_file", "", "Sets the path of the credential file; used in [tls] mode")
+ rootCmd.PersistentFlags().StringVar(&serverNameOverride, "server_name_override", "", "Overrides the peer server name if non empty; used in [tls] mode")
+}
+
+// Execute executes the root command.
+func Execute() {
+ if len(os.Args) > 1 {
+ address = os.Args[1]
+ os.Args = os.Args[1:]
+ } else {
+ rootCmd.Usage()
+ os.Exit(1)
+ }
+ if err := rootCmd.Execute(); err != nil {
+ fmt.Println(err)
+ os.Exit(1)
+ }
+}