forked from InjectiveLabs/peggo
/
peggo.go
103 lines (84 loc) · 2.77 KB
/
peggo.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
package peggo
import (
"fmt"
"io"
"os"
"strings"
"github.com/knadh/koanf"
"github.com/knadh/koanf/providers/env"
"github.com/knadh/koanf/providers/posflag"
"github.com/rs/zerolog"
"github.com/spf13/cobra"
)
func NewRootCmd() *cobra.Command {
cmd := &cobra.Command{
Use: "peggo",
Short: "Peggo is a companion executable for orchestrating a Gravity validator",
Long: `Peggo is a companion executable for orchestrating a Gravity validator.
Inputs in the CLI commands can be provided via flags or environment variables. If
using the later, prefix the environment variable with PEGGO_ and the named of the
flag (e.g. PEGGO_COSMOS_PK).`,
}
cmd.PersistentFlags().String(flagLogLevel, zerolog.InfoLevel.String(), "logging level")
cmd.PersistentFlags().String(flagLogFormat, logLevelText, "logging format (text|json)")
cmd.PersistentFlags().String(flagSvcWaitTimeout, "1m", "Standard wait timeout for external services (e.g. Cosmos daemon gRPC connection)") //nolint: lll
cmd.AddCommand(
getOrchestratorCmd(),
getBridgeCommand(),
getQueryCmd(),
getTxCmd(),
getVersionCmd(),
)
return cmd
}
func getLogger(cmd *cobra.Command) (zerolog.Logger, error) {
logLevelStr, err := cmd.Flags().GetString(flagLogLevel)
if err != nil {
return zerolog.Logger{}, err
}
logLvl, err := zerolog.ParseLevel(logLevelStr)
if err != nil {
return zerolog.Logger{}, err
}
logFormat, err := cmd.Flags().GetString(flagLogFormat)
if err != nil {
return zerolog.Logger{}, err
}
var logWriter io.Writer
switch logFormat {
case logLevelJSON:
logWriter = os.Stderr
case logLevelText:
logWriter = zerolog.ConsoleWriter{Out: os.Stderr}
default:
return zerolog.Logger{}, fmt.Errorf("invalid logging format: %s", logFormat)
}
return zerolog.New(logWriter).Level(logLvl).With().Timestamp().Logger(), nil
}
// parseServerConfig returns a server configuration, given a command Context,
// by parsing the following in order of precedence:
//
// - flags
// - environment variables
// - configuration file (TOML) (TODO)
func parseServerConfig(cmd *cobra.Command) (*koanf.Koanf, error) {
konfig := koanf.New(".")
// load from file first (if provided)
// TODO: Support config files if/when needed.
// if configPath := ctx.String(config.ConfigPath); len(configPath) != 0 {
// if err := konfig.Load(file.Provider(configPath), toml.Parser()); err != nil {
// return nil, err
// }
// }
// load from environment variables
if err := konfig.Load(env.Provider("PEGGO_", ".", func(s string) string {
return strings.ReplaceAll(strings.ToLower(strings.TrimPrefix(s, "PEGGO_")), "_", "-")
}), nil); err != nil {
return nil, err
}
// finally, load from command line flags
if err := konfig.Load(posflag.Provider(cmd.Flags(), ".", konfig), nil); err != nil {
return nil, err
}
return konfig, nil
}