forked from ten-protocol/go-ten
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathcli.go
167 lines (150 loc) · 7.5 KB
/
cli.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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
package hostrunner
import (
"flag"
"fmt"
"os"
"time"
"github.com/obscuronet/go-obscuro/go/common"
"github.com/naoina/toml"
"github.com/obscuronet/go-obscuro/go/config"
gethcommon "github.com/ethereum/go-ethereum/common"
)
// HostConfigToml is the structure that a host's .toml config is parsed into.
type HostConfigToml struct {
ID string
IsGenesis bool
NodeType string
GossipRoundDuration int
HasClientRPCHTTP bool
ClientRPCPortHTTP uint
HasClientRPCWebsockets bool
ClientRPCPortWS uint
ClientRPCHost string
EnclaveRPCAddress string
P2PBindAddress string
P2PPublicAddress string
L1NodeHost string
L1NodeWebsocketPort uint
ClientRPCTimeout int
EnclaveRPCTimeout int
L1RPCTimeout int
P2PConnectionTimeout int
RollupContractAddress string
LogLevel int
LogPath string
PrivateKeyString string
PKAddress string
L1ChainID int64
ObscuroChainID int64
ProfilerEnabled bool
}
// ParseConfig returns a config.HostConfig based on either the file identified by the `config` flag, or the flags with
// specific defaults (if the `config` flag isn't specified).
func ParseConfig() (config.HostConfig, error) {
cfg := config.DefaultHostConfig()
flagUsageMap := getFlagUsageMap()
configPath := flag.String(configName, "", flagUsageMap[configName])
nodeID := flag.String(nodeIDName, cfg.ID.Hex(), flagUsageMap[nodeIDName])
isGenesis := flag.Bool(isGenesisName, cfg.IsGenesis, flagUsageMap[isGenesisName])
nodeTypeStr := flag.String(nodeTypeName, cfg.NodeType.String(), flagUsageMap[nodeTypeName])
gossipRoundNanos := flag.Uint64(gossipRoundNanosName, uint64(cfg.GossipRoundDuration), flagUsageMap[gossipRoundNanosName])
clientRPCPortHTTP := flag.Uint64(clientRPCPortHTTPName, cfg.ClientRPCPortHTTP, flagUsageMap[clientRPCPortHTTPName])
clientRPCPortWS := flag.Uint64(clientRPCPortWSName, cfg.ClientRPCPortWS, flagUsageMap[clientRPCPortWSName])
clientRPCHost := flag.String(clientRPCHostName, cfg.ClientRPCHost, flagUsageMap[clientRPCHostName])
enclaveRPCAddress := flag.String(enclaveRPCAddressName, cfg.EnclaveRPCAddress, flagUsageMap[enclaveRPCAddressName])
p2pBindAddress := flag.String(p2pBindAddressName, cfg.P2PBindAddress, flagUsageMap[p2pBindAddressName])
p2pPublicAddress := flag.String(p2pPublicAddressName, cfg.P2PPublicAddress, flagUsageMap[p2pPublicAddressName])
l1NodeHost := flag.String(l1NodeHostName, cfg.L1NodeHost, flagUsageMap[l1NodeHostName])
l1NodePort := flag.Uint64(l1NodePortName, uint64(cfg.L1NodeWebsocketPort), flagUsageMap[l1NodePortName])
clientRPCTimeoutSecs := flag.Uint64(clientRPCTimeoutSecsName, uint64(cfg.ClientRPCTimeout.Seconds()), flagUsageMap[clientRPCTimeoutSecsName])
enclaveRPCTimeoutSecs := flag.Uint64(enclaveRPCTimeoutSecsName, uint64(cfg.EnclaveRPCTimeout.Seconds()), flagUsageMap[enclaveRPCTimeoutSecsName])
l1RPCTimeoutSecs := flag.Uint64(l1RPCTimeoutSecsName, uint64(cfg.L1RPCTimeout.Seconds()), flagUsageMap[l1RPCTimeoutSecsName])
p2pConnectionTimeoutSecs := flag.Uint64(p2pConnectionTimeoutSecsName, uint64(cfg.P2PConnectionTimeout.Seconds()), flagUsageMap[p2pConnectionTimeoutSecsName])
rollupContractAddress := flag.String(rollupContractAddrName, cfg.RollupContractAddress.Hex(), flagUsageMap[rollupContractAddrName])
logLevel := flag.Int(logLevelName, cfg.LogLevel, flagUsageMap[logLevelName])
logPath := flag.String(logPathName, cfg.LogPath, flagUsageMap[logPathName])
l1ChainID := flag.Int64(l1ChainIDName, cfg.L1ChainID, flagUsageMap[l1ChainIDName])
obscuroChainID := flag.Int64(obscuroChainIDName, cfg.ObscuroChainID, flagUsageMap[obscuroChainIDName])
privateKeyStr := flag.String(privateKeyName, cfg.PrivateKeyString, flagUsageMap[privateKeyName])
pkAddress := flag.String(pkAddressName, cfg.PKAddress, flagUsageMap[pkAddressName])
profilerEnabled := flag.Bool(profilerEnabledName, cfg.ProfilerEnabled, flagUsageMap[profilerEnabledName])
flag.Parse()
if *configPath != "" {
return fileBasedConfig(*configPath)
}
nodeType, err := common.ToNodeType(*nodeTypeStr)
if err != nil {
return config.HostConfig{}, fmt.Errorf("unrecognised node type '%s'", *nodeTypeStr)
}
cfg.ID = gethcommon.HexToAddress(*nodeID)
cfg.IsGenesis = *isGenesis
cfg.NodeType = nodeType
cfg.GossipRoundDuration = time.Duration(*gossipRoundNanos)
cfg.HasClientRPCHTTP = true
cfg.ClientRPCPortHTTP = *clientRPCPortHTTP
cfg.HasClientRPCWebsockets = true
cfg.ClientRPCPortWS = *clientRPCPortWS
cfg.ClientRPCHost = *clientRPCHost
cfg.EnclaveRPCAddress = *enclaveRPCAddress
cfg.P2PBindAddress = *p2pBindAddress
cfg.P2PPublicAddress = *p2pPublicAddress
cfg.L1NodeHost = *l1NodeHost
cfg.L1NodeWebsocketPort = uint(*l1NodePort)
cfg.ClientRPCTimeout = time.Duration(*clientRPCTimeoutSecs) * time.Second
cfg.EnclaveRPCTimeout = time.Duration(*enclaveRPCTimeoutSecs) * time.Second
cfg.L1RPCTimeout = time.Duration(*l1RPCTimeoutSecs) * time.Second
cfg.P2PConnectionTimeout = time.Duration(*p2pConnectionTimeoutSecs) * time.Second
cfg.RollupContractAddress = gethcommon.HexToAddress(*rollupContractAddress)
cfg.PrivateKeyString = *privateKeyStr
cfg.PKAddress = *pkAddress
cfg.LogLevel = *logLevel
cfg.LogPath = *logPath
cfg.L1ChainID = *l1ChainID
cfg.ObscuroChainID = *obscuroChainID
cfg.ProfilerEnabled = *profilerEnabled
return cfg, nil
}
// Parses the config from the .toml file at configPath.
func fileBasedConfig(configPath string) (config.HostConfig, error) {
bytes, err := os.ReadFile(configPath)
if err != nil {
panic(fmt.Sprintf("could not read config file at %s. Cause: %s", configPath, err))
}
var tomlConfig HostConfigToml
err = toml.Unmarshal(bytes, &tomlConfig)
if err != nil {
panic(fmt.Sprintf("could not read config file at %s. Cause: %s", configPath, err))
}
nodeType, err := common.ToNodeType(tomlConfig.NodeType)
if err != nil {
return config.HostConfig{}, fmt.Errorf("unrecognised node type '%s'", tomlConfig.NodeType)
}
return config.HostConfig{
ID: gethcommon.HexToAddress(tomlConfig.ID),
IsGenesis: tomlConfig.IsGenesis,
NodeType: nodeType,
GossipRoundDuration: time.Duration(tomlConfig.GossipRoundDuration),
HasClientRPCHTTP: tomlConfig.HasClientRPCHTTP,
ClientRPCPortHTTP: uint64(tomlConfig.ClientRPCPortHTTP),
HasClientRPCWebsockets: tomlConfig.HasClientRPCWebsockets,
ClientRPCPortWS: uint64(tomlConfig.ClientRPCPortWS),
ClientRPCHost: tomlConfig.ClientRPCHost,
EnclaveRPCAddress: tomlConfig.EnclaveRPCAddress,
P2PBindAddress: tomlConfig.P2PBindAddress,
P2PPublicAddress: tomlConfig.P2PPublicAddress,
L1NodeHost: tomlConfig.L1NodeHost,
L1NodeWebsocketPort: tomlConfig.L1NodeWebsocketPort,
ClientRPCTimeout: time.Duration(tomlConfig.ClientRPCTimeout) * time.Second,
EnclaveRPCTimeout: time.Duration(tomlConfig.EnclaveRPCTimeout) * time.Second,
L1RPCTimeout: time.Duration(tomlConfig.L1RPCTimeout) * time.Second,
P2PConnectionTimeout: time.Duration(tomlConfig.P2PConnectionTimeout) * time.Second,
RollupContractAddress: gethcommon.HexToAddress(tomlConfig.RollupContractAddress),
LogLevel: tomlConfig.LogLevel,
LogPath: tomlConfig.LogPath,
PrivateKeyString: tomlConfig.PrivateKeyString,
PKAddress: tomlConfig.PKAddress,
L1ChainID: tomlConfig.L1ChainID,
ObscuroChainID: tomlConfig.ObscuroChainID,
ProfilerEnabled: tomlConfig.ProfilerEnabled,
}, nil
}