You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1478 lines
44 KiB
1478 lines
44 KiB
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"strconv"
|
|
"strings"
|
|
|
|
harmonyconfig "github.com/harmony-one/harmony/internal/configs/harmony"
|
|
|
|
"github.com/harmony-one/harmony/api/service/legacysync"
|
|
"github.com/harmony-one/harmony/internal/cli"
|
|
nodeconfig "github.com/harmony-one/harmony/internal/configs/node"
|
|
"github.com/spf13/cobra"
|
|
)
|
|
|
|
var (
|
|
generalFlags = []cli.Flag{
|
|
nodeTypeFlag,
|
|
noStakingFlag,
|
|
shardIDFlag,
|
|
isArchiveFlag,
|
|
isBeaconArchiveFlag,
|
|
isOfflineFlag,
|
|
dataDirFlag,
|
|
|
|
legacyNodeTypeFlag,
|
|
legacyIsStakingFlag,
|
|
legacyShardIDFlag,
|
|
legacyIsArchiveFlag,
|
|
legacyDataDirFlag,
|
|
}
|
|
|
|
dnsSyncFlags = []cli.Flag{
|
|
dnsZoneFlag,
|
|
dnsPortFlag,
|
|
dnsServerPortFlag,
|
|
dnsClientFlag,
|
|
dnsServerFlag,
|
|
|
|
syncLegacyClientFlag,
|
|
syncLegacyServerFlag,
|
|
legacyDNSZoneFlag,
|
|
legacyDNSPortFlag,
|
|
legacyDNSFlag,
|
|
}
|
|
|
|
networkFlags = []cli.Flag{
|
|
networkTypeFlag,
|
|
bootNodeFlag,
|
|
legacyNetworkTypeFlag,
|
|
}
|
|
|
|
p2pFlags = []cli.Flag{
|
|
p2pPortFlag,
|
|
p2pIPFlag,
|
|
p2pKeyFileFlag,
|
|
p2pDHTDataStoreFlag,
|
|
|
|
legacyKeyFileFlag,
|
|
}
|
|
|
|
httpFlags = []cli.Flag{
|
|
httpEnabledFlag,
|
|
httpRosettaEnabledFlag,
|
|
httpIPFlag,
|
|
httpPortFlag,
|
|
httpRosettaPortFlag,
|
|
}
|
|
|
|
wsFlags = []cli.Flag{
|
|
wsEnabledFlag,
|
|
wsIPFlag,
|
|
wsPortFlag,
|
|
}
|
|
|
|
rpcOptFlags = []cli.Flag{
|
|
rpcDebugEnabledFlag,
|
|
rpcRateLimiterEnabledFlag,
|
|
rpcRateLimitFlag,
|
|
}
|
|
|
|
blsFlags = append(newBLSFlags, legacyBLSFlags...)
|
|
|
|
newBLSFlags = []cli.Flag{
|
|
blsDirFlag,
|
|
blsKeyFilesFlag,
|
|
maxBLSKeyFilesFlag,
|
|
passEnabledFlag,
|
|
passSrcTypeFlag,
|
|
passSrcFileFlag,
|
|
passSaveFlag,
|
|
kmsEnabledFlag,
|
|
kmsConfigSrcTypeFlag,
|
|
kmsConfigFileFlag,
|
|
}
|
|
|
|
legacyBLSFlags = []cli.Flag{
|
|
legacyBLSKeyFileFlag,
|
|
legacyBLSFolderFlag,
|
|
legacyBLSKeysPerNodeFlag,
|
|
legacyBLSPassFlag,
|
|
legacyBLSPersistPassFlag,
|
|
legacyKMSConfigSourceFlag,
|
|
}
|
|
|
|
consensusFlags = append(consensusValidFlags, consensusInvalidFlags...)
|
|
|
|
// consensusValidFlags are flags that are effective
|
|
consensusValidFlags = []cli.Flag{
|
|
consensusMinPeersFlag,
|
|
consensusAggregateSigFlag,
|
|
legacyConsensusMinPeersFlag,
|
|
}
|
|
|
|
// consensusInvalidFlags are flags that are no longer effective
|
|
consensusInvalidFlags = []cli.Flag{
|
|
legacyDelayCommitFlag,
|
|
legacyBlockTimeFlag,
|
|
}
|
|
|
|
txPoolFlags = []cli.Flag{
|
|
tpBlacklistFileFlag,
|
|
legacyTPBlacklistFileFlag,
|
|
}
|
|
|
|
pprofFlags = []cli.Flag{
|
|
pprofEnabledFlag,
|
|
pprofListenAddrFlag,
|
|
}
|
|
|
|
logFlags = []cli.Flag{
|
|
logFolderFlag,
|
|
logRotateSizeFlag,
|
|
logFileNameFlag,
|
|
logContextIPFlag,
|
|
logContextPortFlag,
|
|
logVerbosityFlag,
|
|
logVerbosePrintsFlag,
|
|
legacyVerbosityFlag,
|
|
|
|
legacyLogFolderFlag,
|
|
legacyLogRotateSizeFlag,
|
|
}
|
|
|
|
sysFlags = []cli.Flag{
|
|
sysNtpServerFlag,
|
|
}
|
|
|
|
devnetFlags = append(newDevnetFlags, legacyDevnetFlags...)
|
|
|
|
newDevnetFlags = []cli.Flag{
|
|
devnetNumShardsFlag,
|
|
devnetShardSizeFlag,
|
|
devnetHmyNodeSizeFlag,
|
|
}
|
|
|
|
legacyDevnetFlags = []cli.Flag{
|
|
legacyDevnetNumShardsFlag,
|
|
legacyDevnetShardSizeFlag,
|
|
legacyDevnetHmyNodeSizeFlag,
|
|
}
|
|
|
|
revertFlags = append(newRevertFlags, legacyRevertFlags...)
|
|
|
|
newRevertFlags = []cli.Flag{
|
|
revertBeaconFlag,
|
|
revertToFlag,
|
|
revertBeforeFlag,
|
|
}
|
|
|
|
legacyRevertFlags = []cli.Flag{
|
|
legacyRevertBeaconFlag,
|
|
legacyRevertBeforeFlag,
|
|
legacyRevertToFlag,
|
|
}
|
|
|
|
// legacyMiscFlags are legacy flags that cannot be categorized to a single category.
|
|
legacyMiscFlags = []cli.Flag{
|
|
legacyPortFlag,
|
|
legacyIPFlag,
|
|
legacyPublicRPCFlag,
|
|
legacyWebHookConfigFlag,
|
|
legacyTPBroadcastInvalidTxFlag,
|
|
}
|
|
|
|
prometheusFlags = []cli.Flag{
|
|
prometheusEnabledFlag,
|
|
prometheusIPFlag,
|
|
prometheusPortFlag,
|
|
prometheusGatewayFlag,
|
|
prometheusEnablePushFlag,
|
|
}
|
|
|
|
syncFlags = []cli.Flag{
|
|
syncStreamEnabledFlag,
|
|
syncDownloaderFlag,
|
|
syncConcurrencyFlag,
|
|
syncMinPeersFlag,
|
|
syncInitStreamsFlag,
|
|
syncDiscSoftLowFlag,
|
|
syncDiscHardLowFlag,
|
|
syncDiscHighFlag,
|
|
syncDiscBatchFlag,
|
|
}
|
|
)
|
|
|
|
var (
|
|
nodeTypeFlag = cli.StringFlag{
|
|
Name: "run",
|
|
Usage: "run node type (validator, explorer)",
|
|
DefValue: defaultConfig.General.NodeType,
|
|
}
|
|
// TODO: Can we rename the legacy to internal?
|
|
noStakingFlag = cli.BoolFlag{
|
|
Name: "run.legacy",
|
|
Usage: "whether to run node in legacy mode",
|
|
DefValue: defaultConfig.General.NoStaking,
|
|
}
|
|
shardIDFlag = cli.IntFlag{
|
|
Name: "run.shard",
|
|
Usage: "run node on the given shard ID (-1 automatically configured by BLS keys)",
|
|
DefValue: defaultConfig.General.ShardID,
|
|
}
|
|
isArchiveFlag = cli.BoolFlag{
|
|
Name: "run.archive",
|
|
Usage: "run shard chain in archive mode",
|
|
DefValue: defaultConfig.General.IsArchival,
|
|
}
|
|
isBeaconArchiveFlag = cli.BoolFlag{
|
|
Name: "run.beacon-archive",
|
|
Usage: "run beacon chain in archive mode",
|
|
DefValue: defaultConfig.General.IsBeaconArchival,
|
|
}
|
|
isOfflineFlag = cli.BoolFlag{
|
|
Name: "run.offline",
|
|
Usage: "run node in offline mode",
|
|
DefValue: defaultConfig.General.IsOffline,
|
|
}
|
|
dataDirFlag = cli.StringFlag{
|
|
Name: "datadir",
|
|
Usage: "directory of chain database",
|
|
DefValue: defaultConfig.General.DataDir,
|
|
}
|
|
legacyNodeTypeFlag = cli.StringFlag{
|
|
Name: "node_type",
|
|
Usage: "run node type (validator, explorer)",
|
|
DefValue: defaultConfig.General.NodeType,
|
|
Deprecated: "use --run",
|
|
}
|
|
legacyIsStakingFlag = cli.BoolFlag{
|
|
Name: "staking",
|
|
Usage: "whether to run node in staking mode",
|
|
DefValue: !defaultConfig.General.NoStaking,
|
|
Deprecated: "use --run.legacy to run in legacy mode",
|
|
}
|
|
legacyShardIDFlag = cli.IntFlag{
|
|
Name: "shard_id",
|
|
Usage: "the shard ID of this node",
|
|
DefValue: defaultConfig.General.ShardID,
|
|
Deprecated: "use --run.shard",
|
|
}
|
|
legacyIsArchiveFlag = cli.BoolFlag{
|
|
Name: "is_archival",
|
|
Usage: "false will enable cached state pruning",
|
|
DefValue: defaultConfig.General.IsArchival,
|
|
Deprecated: "use --run.archive",
|
|
}
|
|
legacyDataDirFlag = cli.StringFlag{
|
|
Name: "db_dir",
|
|
Usage: "blockchain database directory",
|
|
DefValue: defaultConfig.General.DataDir,
|
|
Deprecated: "use --datadir",
|
|
}
|
|
)
|
|
|
|
func getRootFlags() []cli.Flag {
|
|
var flags []cli.Flag
|
|
|
|
flags = append(flags, versionFlag)
|
|
flags = append(flags, configFlag)
|
|
flags = append(flags, generalFlags...)
|
|
flags = append(flags, networkFlags...)
|
|
flags = append(flags, dnsSyncFlags...)
|
|
flags = append(flags, p2pFlags...)
|
|
flags = append(flags, httpFlags...)
|
|
flags = append(flags, wsFlags...)
|
|
flags = append(flags, rpcOptFlags...)
|
|
flags = append(flags, blsFlags...)
|
|
flags = append(flags, consensusFlags...)
|
|
flags = append(flags, txPoolFlags...)
|
|
flags = append(flags, pprofFlags...)
|
|
flags = append(flags, logFlags...)
|
|
flags = append(flags, sysFlags...)
|
|
flags = append(flags, devnetFlags...)
|
|
flags = append(flags, revertFlags...)
|
|
flags = append(flags, legacyMiscFlags...)
|
|
flags = append(flags, prometheusFlags...)
|
|
flags = append(flags, syncFlags...)
|
|
|
|
return flags
|
|
}
|
|
|
|
func applyGeneralFlags(cmd *cobra.Command, config *harmonyconfig.HarmonyConfig) {
|
|
if cli.IsFlagChanged(cmd, nodeTypeFlag) {
|
|
config.General.NodeType = cli.GetStringFlagValue(cmd, nodeTypeFlag)
|
|
} else if cli.IsFlagChanged(cmd, legacyNodeTypeFlag) {
|
|
config.General.NodeType = cli.GetStringFlagValue(cmd, legacyNodeTypeFlag)
|
|
}
|
|
|
|
if config.General.NodeType == nodeTypeExplorer {
|
|
config.General.IsArchival = true
|
|
}
|
|
|
|
if cli.IsFlagChanged(cmd, shardIDFlag) {
|
|
config.General.ShardID = cli.GetIntFlagValue(cmd, shardIDFlag)
|
|
} else if cli.IsFlagChanged(cmd, legacyShardIDFlag) {
|
|
config.General.ShardID = cli.GetIntFlagValue(cmd, legacyShardIDFlag)
|
|
}
|
|
|
|
if cli.IsFlagChanged(cmd, noStakingFlag) {
|
|
config.General.NoStaking = cli.GetBoolFlagValue(cmd, noStakingFlag)
|
|
} else if cli.IsFlagChanged(cmd, legacyIsStakingFlag) {
|
|
config.General.NoStaking = !cli.GetBoolFlagValue(cmd, legacyIsStakingFlag)
|
|
}
|
|
|
|
if cli.IsFlagChanged(cmd, isArchiveFlag) {
|
|
config.General.IsArchival = cli.GetBoolFlagValue(cmd, isArchiveFlag)
|
|
} else if cli.IsFlagChanged(cmd, legacyIsArchiveFlag) {
|
|
config.General.IsArchival = cli.GetBoolFlagValue(cmd, legacyIsArchiveFlag)
|
|
}
|
|
|
|
if cli.IsFlagChanged(cmd, isBeaconArchiveFlag) {
|
|
config.General.IsBeaconArchival = cli.GetBoolFlagValue(cmd, isBeaconArchiveFlag)
|
|
}
|
|
|
|
if cli.IsFlagChanged(cmd, dataDirFlag) {
|
|
config.General.DataDir = cli.GetStringFlagValue(cmd, dataDirFlag)
|
|
} else if cli.IsFlagChanged(cmd, legacyDataDirFlag) {
|
|
config.General.DataDir = cli.GetStringFlagValue(cmd, legacyDataDirFlag)
|
|
}
|
|
|
|
if cli.IsFlagChanged(cmd, isOfflineFlag) {
|
|
config.General.IsOffline = cli.GetBoolFlagValue(cmd, isOfflineFlag)
|
|
}
|
|
}
|
|
|
|
// network flags
|
|
var (
|
|
networkTypeFlag = cli.StringFlag{
|
|
Name: "network",
|
|
Shorthand: "n",
|
|
DefValue: "mainnet",
|
|
Usage: "network to join (mainnet, testnet, pangaea, localnet, partner, stressnet, devnet)",
|
|
}
|
|
bootNodeFlag = cli.StringSliceFlag{
|
|
Name: "bootnodes",
|
|
Usage: "a list of bootnode multiaddress (delimited by ,)",
|
|
}
|
|
legacyDNSZoneFlag = cli.StringFlag{
|
|
Name: "dns_zone",
|
|
Usage: "use peers from the zone for state syncing",
|
|
Deprecated: "use --dns.zone",
|
|
}
|
|
legacyNetworkTypeFlag = cli.StringFlag{
|
|
Name: "network_type",
|
|
Usage: "network to join (mainnet, testnet, pangaea, localnet, partner, stressnet, devnet)",
|
|
Deprecated: "use --network",
|
|
}
|
|
)
|
|
|
|
// DNSSync flags
|
|
var (
|
|
legacyDNSPortFlag = cli.IntFlag{
|
|
Name: "dns_port",
|
|
Usage: "port of dns node",
|
|
Deprecated: "use --dns.port",
|
|
}
|
|
legacyDNSFlag = cli.BoolFlag{
|
|
Name: "dns",
|
|
DefValue: true,
|
|
Hidden: true,
|
|
Usage: "use dns for syncing",
|
|
Deprecated: "only set to false to use self discovered peers for syncing",
|
|
}
|
|
dnsZoneFlag = cli.StringFlag{
|
|
Name: "dns.zone",
|
|
Usage: "use customized peers from the zone for state syncing",
|
|
}
|
|
dnsPortFlag = cli.IntFlag{
|
|
Name: "dns.port",
|
|
DefValue: nodeconfig.DefaultDNSPort,
|
|
Usage: "dns sync remote server port",
|
|
}
|
|
dnsServerPortFlag = cli.IntFlag{
|
|
Name: "dns.server-port",
|
|
DefValue: nodeconfig.DefaultDNSPort,
|
|
Usage: "dns sync local server port",
|
|
}
|
|
syncLegacyClientFlag = cli.BoolFlag{
|
|
Name: "sync.legacy.client",
|
|
Usage: "Enable the legacy centralized sync service for block synchronization",
|
|
Hidden: true,
|
|
DefValue: false,
|
|
Deprecated: "use dns.client instead",
|
|
}
|
|
dnsClientFlag = cli.BoolFlag{
|
|
Name: "dns.client",
|
|
Usage: "Enable the legacy centralized sync service for block synchronization",
|
|
Hidden: true,
|
|
DefValue: false,
|
|
}
|
|
syncLegacyServerFlag = cli.BoolFlag{
|
|
Name: "sync.legacy.server",
|
|
Usage: "Enable the gRPC sync server for backward compatibility",
|
|
Hidden: true,
|
|
DefValue: true,
|
|
Deprecated: "use dns.server instead",
|
|
}
|
|
dnsServerFlag = cli.BoolFlag{
|
|
Name: "dns.server",
|
|
Usage: "Enable the gRPC sync server for backward compatibility",
|
|
Hidden: true,
|
|
DefValue: true,
|
|
}
|
|
)
|
|
|
|
func getNetworkType(cmd *cobra.Command) nodeconfig.NetworkType {
|
|
var raw string
|
|
|
|
if cli.IsFlagChanged(cmd, networkTypeFlag) {
|
|
raw = cli.GetStringFlagValue(cmd, networkTypeFlag)
|
|
} else if cli.IsFlagChanged(cmd, legacyNetworkTypeFlag) {
|
|
raw = cli.GetStringFlagValue(cmd, legacyNetworkTypeFlag)
|
|
} else {
|
|
raw = defaultConfig.Network.NetworkType
|
|
}
|
|
return parseNetworkType(raw)
|
|
}
|
|
|
|
func applyDNSSyncFlags(cmd *cobra.Command, cfg *harmonyconfig.HarmonyConfig) {
|
|
if cli.IsFlagChanged(cmd, dnsZoneFlag) {
|
|
cfg.DNSSync.Zone = cli.GetStringFlagValue(cmd, dnsZoneFlag)
|
|
} else if cli.IsFlagChanged(cmd, legacyDNSZoneFlag) {
|
|
cfg.DNSSync.Zone = cli.GetStringFlagValue(cmd, legacyDNSZoneFlag)
|
|
} else if cli.IsFlagChanged(cmd, legacyDNSFlag) {
|
|
val := cli.GetBoolFlagValue(cmd, legacyDNSFlag)
|
|
if !val {
|
|
cfg.DNSSync.LegacySyncing = true
|
|
}
|
|
}
|
|
|
|
if cli.IsFlagChanged(cmd, dnsPortFlag) {
|
|
cfg.DNSSync.Port = cli.GetIntFlagValue(cmd, dnsPortFlag)
|
|
} else if cli.IsFlagChanged(cmd, legacyDNSPortFlag) {
|
|
cfg.DNSSync.Port = cli.GetIntFlagValue(cmd, legacyDNSPortFlag)
|
|
}
|
|
|
|
if cli.IsFlagChanged(cmd, syncLegacyServerFlag) {
|
|
cfg.DNSSync.Server = cli.GetBoolFlagValue(cmd, syncLegacyServerFlag)
|
|
} else if cli.IsFlagChanged(cmd, dnsServerFlag) {
|
|
cfg.DNSSync.Server = cli.GetBoolFlagValue(cmd, syncLegacyServerFlag)
|
|
}
|
|
|
|
if cli.IsFlagChanged(cmd, syncLegacyClientFlag) {
|
|
cfg.DNSSync.Client = cli.GetBoolFlagValue(cmd, syncLegacyClientFlag)
|
|
} else if cli.IsFlagChanged(cmd, dnsClientFlag) {
|
|
cfg.DNSSync.Client = cli.GetBoolFlagValue(cmd, dnsClientFlag)
|
|
}
|
|
|
|
if cli.IsFlagChanged(cmd, dnsServerPortFlag) {
|
|
cfg.DNSSync.ServerPort = cli.GetIntFlagValue(cmd, dnsServerPortFlag)
|
|
}
|
|
|
|
}
|
|
|
|
func applyNetworkFlags(cmd *cobra.Command, cfg *harmonyconfig.HarmonyConfig) {
|
|
if cli.IsFlagChanged(cmd, bootNodeFlag) {
|
|
cfg.Network.BootNodes = cli.GetStringSliceFlagValue(cmd, bootNodeFlag)
|
|
}
|
|
}
|
|
|
|
// p2p flags
|
|
var (
|
|
p2pPortFlag = cli.IntFlag{
|
|
Name: "p2p.port",
|
|
Usage: "port to listen for p2p protocols",
|
|
DefValue: defaultConfig.P2P.Port,
|
|
}
|
|
p2pIPFlag = cli.StringFlag{
|
|
Name: "p2p.ip",
|
|
Usage: "ip to listen for p2p protocols",
|
|
DefValue: defaultConfig.P2P.IP,
|
|
}
|
|
p2pKeyFileFlag = cli.StringFlag{
|
|
Name: "p2p.keyfile",
|
|
Usage: "the p2p key file of the harmony node",
|
|
DefValue: defaultConfig.P2P.KeyFile,
|
|
}
|
|
p2pDHTDataStoreFlag = cli.StringFlag{
|
|
Name: "p2p.dht.datastore",
|
|
Usage: "the datastore file to persist the dht routing table",
|
|
DefValue: "",
|
|
Hidden: true,
|
|
}
|
|
legacyKeyFileFlag = cli.StringFlag{
|
|
Name: "key",
|
|
Usage: "the p2p key file of the harmony node",
|
|
DefValue: defaultConfig.P2P.KeyFile,
|
|
Deprecated: "use --p2p.keyfile",
|
|
}
|
|
)
|
|
|
|
func applyP2PFlags(cmd *cobra.Command, config *harmonyconfig.HarmonyConfig) {
|
|
if cli.IsFlagChanged(cmd, p2pPortFlag) {
|
|
config.P2P.Port = cli.GetIntFlagValue(cmd, p2pPortFlag)
|
|
}
|
|
if cli.IsFlagChanged(cmd, p2pIPFlag) {
|
|
config.P2P.IP = cli.GetStringFlagValue(cmd, p2pIPFlag)
|
|
}
|
|
if config.General.IsOffline {
|
|
config.P2P.IP = nodeconfig.DefaultLocalListenIP
|
|
}
|
|
|
|
if cli.IsFlagChanged(cmd, p2pKeyFileFlag) {
|
|
config.P2P.KeyFile = cli.GetStringFlagValue(cmd, p2pKeyFileFlag)
|
|
} else if cli.IsFlagChanged(cmd, legacyKeyFileFlag) {
|
|
config.P2P.KeyFile = cli.GetStringFlagValue(cmd, legacyKeyFileFlag)
|
|
}
|
|
|
|
if cli.IsFlagChanged(cmd, p2pDHTDataStoreFlag) {
|
|
ds := cli.GetStringFlagValue(cmd, p2pDHTDataStoreFlag)
|
|
config.P2P.DHTDataStore = &ds
|
|
}
|
|
}
|
|
|
|
// http flags
|
|
var (
|
|
httpEnabledFlag = cli.BoolFlag{
|
|
Name: "http",
|
|
Usage: "enable HTTP / RPC requests",
|
|
DefValue: defaultConfig.HTTP.Enabled,
|
|
}
|
|
httpIPFlag = cli.StringFlag{
|
|
Name: "http.ip",
|
|
Usage: "ip address to listen for RPC calls. Use 0.0.0.0 for public endpoint",
|
|
DefValue: defaultConfig.HTTP.IP,
|
|
}
|
|
httpPortFlag = cli.IntFlag{
|
|
Name: "http.port",
|
|
Usage: "rpc port to listen for HTTP requests",
|
|
DefValue: defaultConfig.HTTP.Port,
|
|
}
|
|
httpRosettaEnabledFlag = cli.BoolFlag{
|
|
Name: "http.rosetta",
|
|
Usage: "enable HTTP / Rosetta requests",
|
|
DefValue: defaultConfig.HTTP.RosettaEnabled,
|
|
}
|
|
httpRosettaPortFlag = cli.IntFlag{
|
|
Name: "http.rosetta.port",
|
|
Usage: "rosetta port to listen for HTTP requests",
|
|
DefValue: defaultConfig.HTTP.RosettaPort,
|
|
}
|
|
)
|
|
|
|
func applyHTTPFlags(cmd *cobra.Command, config *harmonyconfig.HarmonyConfig) {
|
|
var isRPCSpecified, isRosettaSpecified bool
|
|
|
|
if cli.IsFlagChanged(cmd, httpIPFlag) {
|
|
config.HTTP.IP = cli.GetStringFlagValue(cmd, httpIPFlag)
|
|
isRPCSpecified = true
|
|
}
|
|
|
|
if cli.IsFlagChanged(cmd, httpPortFlag) {
|
|
config.HTTP.Port = cli.GetIntFlagValue(cmd, httpPortFlag)
|
|
isRPCSpecified = true
|
|
}
|
|
|
|
if cli.IsFlagChanged(cmd, httpRosettaPortFlag) {
|
|
config.HTTP.RosettaPort = cli.GetIntFlagValue(cmd, httpRosettaPortFlag)
|
|
isRosettaSpecified = true
|
|
}
|
|
|
|
if cli.IsFlagChanged(cmd, httpRosettaEnabledFlag) {
|
|
config.HTTP.RosettaEnabled = cli.GetBoolFlagValue(cmd, httpRosettaEnabledFlag)
|
|
} else if isRosettaSpecified {
|
|
config.HTTP.RosettaEnabled = true
|
|
}
|
|
|
|
if cli.IsFlagChanged(cmd, httpEnabledFlag) {
|
|
config.HTTP.Enabled = cli.GetBoolFlagValue(cmd, httpEnabledFlag)
|
|
} else if isRPCSpecified {
|
|
config.HTTP.Enabled = true
|
|
}
|
|
|
|
}
|
|
|
|
// ws flags
|
|
var (
|
|
wsEnabledFlag = cli.BoolFlag{
|
|
Name: "ws",
|
|
Usage: "enable websocket endpoint",
|
|
DefValue: defaultConfig.WS.Enabled,
|
|
}
|
|
wsIPFlag = cli.StringFlag{
|
|
Name: "ws.ip",
|
|
Usage: "ip endpoint for websocket. Use 0.0.0.0 for public endpoint",
|
|
DefValue: defaultConfig.WS.IP,
|
|
}
|
|
wsPortFlag = cli.IntFlag{
|
|
Name: "ws.port",
|
|
Usage: "port for websocket endpoint",
|
|
DefValue: defaultConfig.WS.Port,
|
|
}
|
|
)
|
|
|
|
func applyWSFlags(cmd *cobra.Command, config *harmonyconfig.HarmonyConfig) {
|
|
if cli.IsFlagChanged(cmd, wsEnabledFlag) {
|
|
config.WS.Enabled = cli.GetBoolFlagValue(cmd, wsEnabledFlag)
|
|
}
|
|
if cli.IsFlagChanged(cmd, wsIPFlag) {
|
|
config.WS.IP = cli.GetStringFlagValue(cmd, wsIPFlag)
|
|
}
|
|
if cli.IsFlagChanged(cmd, wsPortFlag) {
|
|
config.WS.Port = cli.GetIntFlagValue(cmd, wsPortFlag)
|
|
}
|
|
}
|
|
|
|
// rpc opt flags
|
|
var (
|
|
rpcDebugEnabledFlag = cli.BoolFlag{
|
|
Name: "rpc.debug",
|
|
Usage: "enable private debug apis",
|
|
DefValue: defaultConfig.RPCOpt.DebugEnabled,
|
|
Hidden: true,
|
|
}
|
|
|
|
rpcRateLimiterEnabledFlag = cli.BoolFlag{
|
|
Name: "rpc.ratelimiter",
|
|
Usage: "enable rate limiter for RPCs",
|
|
DefValue: defaultConfig.RPCOpt.RateLimterEnabled,
|
|
}
|
|
|
|
rpcRateLimitFlag = cli.IntFlag{
|
|
Name: "rpc.ratelimit",
|
|
Usage: "the number of requests per second for RPCs",
|
|
DefValue: defaultConfig.RPCOpt.RequestsPerSecond,
|
|
}
|
|
)
|
|
|
|
func applyRPCOptFlags(cmd *cobra.Command, config *harmonyconfig.HarmonyConfig) {
|
|
if cli.IsFlagChanged(cmd, rpcDebugEnabledFlag) {
|
|
config.RPCOpt.DebugEnabled = cli.GetBoolFlagValue(cmd, rpcDebugEnabledFlag)
|
|
}
|
|
if cli.IsFlagChanged(cmd, rpcRateLimiterEnabledFlag) {
|
|
config.RPCOpt.RateLimterEnabled = cli.GetBoolFlagValue(cmd, rpcRateLimiterEnabledFlag)
|
|
}
|
|
if cli.IsFlagChanged(cmd, rpcRateLimitFlag) {
|
|
config.RPCOpt.RequestsPerSecond = cli.GetIntFlagValue(cmd, rpcRateLimitFlag)
|
|
}
|
|
|
|
}
|
|
|
|
// bls flags
|
|
var (
|
|
blsDirFlag = cli.StringFlag{
|
|
Name: "bls.dir",
|
|
Usage: "directory for BLS keys",
|
|
DefValue: defaultConfig.BLSKeys.KeyDir,
|
|
}
|
|
blsKeyFilesFlag = cli.StringSliceFlag{
|
|
Name: "bls.keys",
|
|
Usage: "a list of BLS key files (separated by ,)",
|
|
DefValue: defaultConfig.BLSKeys.KeyFiles,
|
|
}
|
|
// TODO: shall we move this to a hard coded parameter?
|
|
maxBLSKeyFilesFlag = cli.IntFlag{
|
|
Name: "bls.maxkeys",
|
|
Usage: "maximum number of BLS keys for a node",
|
|
DefValue: defaultConfig.BLSKeys.MaxKeys,
|
|
Hidden: true,
|
|
}
|
|
passEnabledFlag = cli.BoolFlag{
|
|
Name: "bls.pass",
|
|
Usage: "enable BLS key decryption with passphrase",
|
|
DefValue: defaultConfig.BLSKeys.PassEnabled,
|
|
}
|
|
passSrcTypeFlag = cli.StringFlag{
|
|
Name: "bls.pass.src",
|
|
Usage: "source for BLS passphrase (auto, file, prompt)",
|
|
DefValue: defaultConfig.BLSKeys.PassSrcType,
|
|
}
|
|
passSrcFileFlag = cli.StringFlag{
|
|
Name: "bls.pass.file",
|
|
Usage: "the pass file used for BLS decryption. If specified, this pass file will be used for all BLS keys",
|
|
DefValue: defaultConfig.BLSKeys.PassFile,
|
|
}
|
|
passSaveFlag = cli.BoolFlag{
|
|
Name: "bls.pass.save",
|
|
Usage: "after input the BLS passphrase from console, whether to persist the input passphrases in .pass file",
|
|
DefValue: defaultConfig.BLSKeys.SavePassphrase,
|
|
}
|
|
kmsEnabledFlag = cli.BoolFlag{
|
|
Name: "bls.kms",
|
|
Usage: "enable BLS key decryption with AWS KMS service",
|
|
DefValue: defaultConfig.BLSKeys.KMSEnabled,
|
|
}
|
|
kmsConfigSrcTypeFlag = cli.StringFlag{
|
|
Name: "bls.kms.src",
|
|
Usage: "the AWS config source (region and credentials) for KMS service (shared, prompt, file)",
|
|
DefValue: defaultConfig.BLSKeys.KMSConfigSrcType,
|
|
}
|
|
kmsConfigFileFlag = cli.StringFlag{
|
|
Name: "bls.kms.config",
|
|
Usage: "json config file for KMS service (region and credentials)",
|
|
DefValue: defaultConfig.BLSKeys.KMSConfigFile,
|
|
}
|
|
legacyBLSKeyFileFlag = cli.StringSliceFlag{
|
|
Name: "blskey_file",
|
|
Usage: "The encrypted file of bls serialized private key by passphrase.",
|
|
DefValue: defaultConfig.BLSKeys.KeyFiles,
|
|
Deprecated: "use --bls.keys",
|
|
}
|
|
legacyBLSFolderFlag = cli.StringFlag{
|
|
Name: "blsfolder",
|
|
Usage: "The folder that stores the bls keys and corresponding passphrases; e.g. <blskey>.key and <blskey>.pass; all bls keys mapped to same shard",
|
|
DefValue: defaultConfig.BLSKeys.KeyDir,
|
|
Deprecated: "use --bls.dir",
|
|
}
|
|
legacyBLSKeysPerNodeFlag = cli.IntFlag{
|
|
Name: "max_bls_keys_per_node",
|
|
Usage: "Maximum number of bls keys allowed per node",
|
|
DefValue: defaultConfig.BLSKeys.MaxKeys,
|
|
Deprecated: "use --bls.maxkeys",
|
|
}
|
|
legacyBLSPassFlag = cli.StringFlag{
|
|
Name: "blspass",
|
|
Usage: "The source for bls passphrases. (default, stdin, no-prompt, prompt, file:$PASS_FILE, none)",
|
|
DefValue: "default",
|
|
Deprecated: "use --bls.pass, --bls.pass.src, --bls.pass.file",
|
|
}
|
|
legacyBLSPersistPassFlag = cli.BoolFlag{
|
|
Name: "save-passphrase",
|
|
Usage: "Whether the prompt passphrase is saved after prompt.",
|
|
DefValue: defaultConfig.BLSKeys.SavePassphrase,
|
|
Deprecated: "use --bls.pass.save",
|
|
}
|
|
legacyKMSConfigSourceFlag = cli.StringFlag{
|
|
Name: "aws-config-source",
|
|
Usage: "The source for aws config. (default, prompt, file:$CONFIG_FILE, none)",
|
|
DefValue: "default",
|
|
Deprecated: "use --bls.kms, --bls.kms.src, --bls.kms.config",
|
|
}
|
|
)
|
|
|
|
func applyBLSFlags(cmd *cobra.Command, config *harmonyconfig.HarmonyConfig) {
|
|
if cli.IsFlagChanged(cmd, blsDirFlag) {
|
|
config.BLSKeys.KeyDir = cli.GetStringFlagValue(cmd, blsDirFlag)
|
|
} else if cli.IsFlagChanged(cmd, legacyBLSFolderFlag) {
|
|
config.BLSKeys.KeyDir = cli.GetStringFlagValue(cmd, legacyBLSFolderFlag)
|
|
}
|
|
|
|
if cli.IsFlagChanged(cmd, blsKeyFilesFlag) {
|
|
config.BLSKeys.KeyFiles = cli.GetStringSliceFlagValue(cmd, blsKeyFilesFlag)
|
|
} else if cli.IsFlagChanged(cmd, legacyBLSKeyFileFlag) {
|
|
config.BLSKeys.KeyFiles = cli.GetStringSliceFlagValue(cmd, legacyBLSKeyFileFlag)
|
|
}
|
|
|
|
if cli.IsFlagChanged(cmd, maxBLSKeyFilesFlag) {
|
|
config.BLSKeys.MaxKeys = cli.GetIntFlagValue(cmd, maxBLSKeyFilesFlag)
|
|
} else if cli.IsFlagChanged(cmd, legacyBLSKeysPerNodeFlag) {
|
|
config.BLSKeys.MaxKeys = cli.GetIntFlagValue(cmd, legacyBLSKeysPerNodeFlag)
|
|
}
|
|
|
|
if cli.HasFlagsChanged(cmd, newBLSFlags) {
|
|
applyBLSPassFlags(cmd, config)
|
|
applyKMSFlags(cmd, config)
|
|
} else if cli.HasFlagsChanged(cmd, legacyBLSFlags) {
|
|
applyLegacyBLSPassFlags(cmd, config)
|
|
applyLegacyKMSFlags(cmd, config)
|
|
}
|
|
}
|
|
|
|
func applyBLSPassFlags(cmd *cobra.Command, config *harmonyconfig.HarmonyConfig) {
|
|
var passFileSpecified bool
|
|
|
|
if cli.IsFlagChanged(cmd, passEnabledFlag) {
|
|
config.BLSKeys.PassEnabled = cli.GetBoolFlagValue(cmd, passEnabledFlag)
|
|
}
|
|
if cli.IsFlagChanged(cmd, passSrcFileFlag) {
|
|
config.BLSKeys.PassFile = cli.GetStringFlagValue(cmd, passSrcFileFlag)
|
|
passFileSpecified = true
|
|
}
|
|
if cli.IsFlagChanged(cmd, passSaveFlag) {
|
|
config.BLSKeys.SavePassphrase = cli.GetBoolFlagValue(cmd, passSaveFlag)
|
|
}
|
|
if cli.IsFlagChanged(cmd, passSrcTypeFlag) {
|
|
config.BLSKeys.PassSrcType = cli.GetStringFlagValue(cmd, passSrcTypeFlag)
|
|
} else if passFileSpecified {
|
|
config.BLSKeys.PassSrcType = blsPassTypeFile
|
|
}
|
|
}
|
|
|
|
func applyKMSFlags(cmd *cobra.Command, config *harmonyconfig.HarmonyConfig) {
|
|
var fileSpecified bool
|
|
|
|
if cli.IsFlagChanged(cmd, kmsEnabledFlag) {
|
|
config.BLSKeys.KMSEnabled = cli.GetBoolFlagValue(cmd, kmsEnabledFlag)
|
|
}
|
|
if cli.IsFlagChanged(cmd, kmsConfigFileFlag) {
|
|
config.BLSKeys.KMSConfigFile = cli.GetStringFlagValue(cmd, kmsConfigFileFlag)
|
|
fileSpecified = true
|
|
}
|
|
if cli.IsFlagChanged(cmd, kmsConfigSrcTypeFlag) {
|
|
config.BLSKeys.KMSConfigSrcType = cli.GetStringFlagValue(cmd, kmsConfigSrcTypeFlag)
|
|
} else if fileSpecified {
|
|
config.BLSKeys.KMSConfigSrcType = blsPassTypeFile
|
|
}
|
|
}
|
|
|
|
func applyLegacyBLSPassFlags(cmd *cobra.Command, config *harmonyconfig.HarmonyConfig) {
|
|
if cli.IsFlagChanged(cmd, legacyBLSPassFlag) {
|
|
val := cli.GetStringFlagValue(cmd, legacyBLSPassFlag)
|
|
legacyApplyBLSPassVal(val, config)
|
|
}
|
|
if cli.IsFlagChanged(cmd, legacyBLSPersistPassFlag) {
|
|
config.BLSKeys.SavePassphrase = cli.GetBoolFlagValue(cmd, legacyBLSPersistPassFlag)
|
|
}
|
|
}
|
|
|
|
func applyLegacyKMSFlags(cmd *cobra.Command, config *harmonyconfig.HarmonyConfig) {
|
|
if cli.IsFlagChanged(cmd, legacyKMSConfigSourceFlag) {
|
|
val := cli.GetStringFlagValue(cmd, legacyKMSConfigSourceFlag)
|
|
legacyApplyKMSSourceVal(val, config)
|
|
}
|
|
}
|
|
|
|
func legacyApplyBLSPassVal(src string, config *harmonyconfig.HarmonyConfig) {
|
|
methodArgs := strings.SplitN(src, ":", 2)
|
|
method := methodArgs[0]
|
|
|
|
switch method {
|
|
case legacyBLSPassTypeDefault, legacyBLSPassTypeStdin:
|
|
config.BLSKeys.PassSrcType = blsPassTypeAuto
|
|
case legacyBLSPassTypeStatic:
|
|
config.BLSKeys.PassSrcType = blsPassTypeFile
|
|
if len(methodArgs) >= 2 {
|
|
config.BLSKeys.PassFile = methodArgs[1]
|
|
}
|
|
case legacyBLSPassTypeDynamic:
|
|
config.BLSKeys.PassSrcType = blsPassTypePrompt
|
|
case legacyBLSPassTypePrompt:
|
|
config.BLSKeys.PassSrcType = blsPassTypePrompt
|
|
case legacyBLSPassTypeNone:
|
|
config.BLSKeys.PassEnabled = false
|
|
}
|
|
}
|
|
|
|
func legacyApplyKMSSourceVal(src string, config *harmonyconfig.HarmonyConfig) {
|
|
methodArgs := strings.SplitN(src, ":", 2)
|
|
method := methodArgs[0]
|
|
|
|
switch method {
|
|
case legacyBLSKmsTypeDefault:
|
|
config.BLSKeys.KMSConfigSrcType = kmsConfigTypeShared
|
|
case legacyBLSKmsTypePrompt:
|
|
config.BLSKeys.KMSConfigSrcType = kmsConfigTypePrompt
|
|
case legacyBLSKmsTypeFile:
|
|
config.BLSKeys.KMSConfigSrcType = kmsConfigTypeFile
|
|
if len(methodArgs) >= 2 {
|
|
config.BLSKeys.KMSConfigFile = methodArgs[1]
|
|
}
|
|
case legacyBLSKmsTypeNone:
|
|
config.BLSKeys.KMSEnabled = false
|
|
}
|
|
}
|
|
|
|
// consensus flags
|
|
var (
|
|
consensusMinPeersFlag = cli.IntFlag{
|
|
Name: "consensus.min-peers",
|
|
Usage: "minimal number of peers in shard",
|
|
DefValue: defaultConsensusConfig.MinPeers,
|
|
Hidden: true,
|
|
}
|
|
consensusAggregateSigFlag = cli.BoolFlag{
|
|
Name: "consensus.aggregate-sig",
|
|
Usage: "(multi-key) aggregate bls signatures before sending",
|
|
DefValue: defaultConsensusConfig.AggregateSig,
|
|
}
|
|
legacyDelayCommitFlag = cli.StringFlag{
|
|
Name: "delay_commit",
|
|
Usage: "how long to delay sending commit messages in consensus, ex: 500ms, 1s",
|
|
Deprecated: "flag delay_commit is no longer effective",
|
|
}
|
|
legacyBlockTimeFlag = cli.IntFlag{
|
|
Name: "block_period",
|
|
Usage: "how long in second the leader waits to propose a new block",
|
|
DefValue: 5,
|
|
Deprecated: "flag block_period is no longer effective",
|
|
}
|
|
legacyConsensusMinPeersFlag = cli.IntFlag{
|
|
Name: "min_peers",
|
|
Usage: "Minimal number of Peers in shard",
|
|
DefValue: defaultConsensusConfig.MinPeers,
|
|
Hidden: true,
|
|
}
|
|
)
|
|
|
|
func applyConsensusFlags(cmd *cobra.Command, config *harmonyconfig.HarmonyConfig) {
|
|
if config.Consensus == nil && cli.HasFlagsChanged(cmd, consensusValidFlags) {
|
|
cfg := getDefaultConsensusConfigCopy()
|
|
config.Consensus = &cfg
|
|
}
|
|
|
|
if cli.IsFlagChanged(cmd, consensusMinPeersFlag) {
|
|
config.Consensus.MinPeers = cli.GetIntFlagValue(cmd, consensusMinPeersFlag)
|
|
} else if cli.IsFlagChanged(cmd, legacyConsensusMinPeersFlag) {
|
|
config.Consensus.MinPeers = cli.GetIntFlagValue(cmd, legacyConsensusMinPeersFlag)
|
|
}
|
|
|
|
if cli.IsFlagChanged(cmd, consensusAggregateSigFlag) {
|
|
config.Consensus.AggregateSig = cli.GetBoolFlagValue(cmd, consensusAggregateSigFlag)
|
|
}
|
|
}
|
|
|
|
// transaction pool flags
|
|
var (
|
|
tpBlacklistFileFlag = cli.StringFlag{
|
|
Name: "txpool.blacklist",
|
|
Usage: "file of blacklisted wallet addresses",
|
|
DefValue: defaultConfig.TxPool.BlacklistFile,
|
|
}
|
|
legacyTPBlacklistFileFlag = cli.StringFlag{
|
|
Name: "blacklist",
|
|
Usage: "Path to newline delimited file of blacklisted wallet addresses",
|
|
DefValue: defaultConfig.TxPool.BlacklistFile,
|
|
Deprecated: "use --txpool.blacklist",
|
|
}
|
|
)
|
|
|
|
func applyTxPoolFlags(cmd *cobra.Command, config *harmonyconfig.HarmonyConfig) {
|
|
if cli.IsFlagChanged(cmd, tpBlacklistFileFlag) {
|
|
config.TxPool.BlacklistFile = cli.GetStringFlagValue(cmd, tpBlacklistFileFlag)
|
|
} else if cli.IsFlagChanged(cmd, legacyTPBlacklistFileFlag) {
|
|
config.TxPool.BlacklistFile = cli.GetStringFlagValue(cmd, legacyTPBlacklistFileFlag)
|
|
}
|
|
}
|
|
|
|
// pprof flags
|
|
var (
|
|
pprofEnabledFlag = cli.BoolFlag{
|
|
Name: "pprof",
|
|
Usage: "enable pprof profiling",
|
|
DefValue: defaultConfig.Pprof.Enabled,
|
|
}
|
|
pprofListenAddrFlag = cli.StringFlag{
|
|
Name: "pprof.addr",
|
|
Usage: "listen address for pprof",
|
|
DefValue: defaultConfig.Pprof.ListenAddr,
|
|
}
|
|
)
|
|
|
|
func applyPprofFlags(cmd *cobra.Command, config *harmonyconfig.HarmonyConfig) {
|
|
var pprofSet bool
|
|
if cli.IsFlagChanged(cmd, pprofListenAddrFlag) {
|
|
config.Pprof.ListenAddr = cli.GetStringFlagValue(cmd, pprofListenAddrFlag)
|
|
pprofSet = true
|
|
}
|
|
if cli.IsFlagChanged(cmd, pprofEnabledFlag) {
|
|
config.Pprof.Enabled = cli.GetBoolFlagValue(cmd, pprofEnabledFlag)
|
|
} else if pprofSet {
|
|
config.Pprof.Enabled = true
|
|
}
|
|
}
|
|
|
|
// log flags
|
|
var (
|
|
logFolderFlag = cli.StringFlag{
|
|
Name: "log.dir",
|
|
Usage: "directory path to put rotation logs",
|
|
DefValue: defaultConfig.Log.Folder,
|
|
}
|
|
logRotateSizeFlag = cli.IntFlag{
|
|
Name: "log.max-size",
|
|
Usage: "rotation log size in megabytes",
|
|
DefValue: defaultConfig.Log.RotateSize,
|
|
}
|
|
logFileNameFlag = cli.StringFlag{
|
|
Name: "log.name",
|
|
Usage: "log file name (e.g. harmony.log)",
|
|
DefValue: defaultConfig.Log.FileName,
|
|
}
|
|
logVerbosityFlag = cli.IntFlag{
|
|
Name: "log.verb",
|
|
Shorthand: "v",
|
|
Usage: "logging verbosity: 0=silent, 1=error, 2=warn, 3=info, 4=debug, 5=detail",
|
|
DefValue: defaultConfig.Log.Verbosity,
|
|
}
|
|
logVerbosePrintsFlag = cli.StringSliceFlag{
|
|
Name: "log.verbose-prints",
|
|
Usage: "debugging feature. to print verbose internal objects as JSON in log file. available internal objects: config",
|
|
DefValue: []string{"config"},
|
|
}
|
|
// TODO: remove context (this shall not be in the log)
|
|
logContextIPFlag = cli.StringFlag{
|
|
Name: "log.ctx.ip",
|
|
Usage: "log context ip",
|
|
DefValue: defaultLogContext.IP,
|
|
Hidden: true,
|
|
}
|
|
logContextPortFlag = cli.IntFlag{
|
|
Name: "log.ctx.port",
|
|
Usage: "log context port",
|
|
DefValue: defaultLogContext.Port,
|
|
Hidden: true,
|
|
}
|
|
legacyLogFolderFlag = cli.StringFlag{
|
|
Name: "log_folder",
|
|
Usage: "the folder collecting the logs of this execution",
|
|
DefValue: defaultConfig.Log.Folder,
|
|
Deprecated: "use --log.path",
|
|
}
|
|
legacyLogRotateSizeFlag = cli.IntFlag{
|
|
Name: "log_max_size",
|
|
Usage: "the max size in megabytes of the log file before it gets rotated",
|
|
DefValue: defaultConfig.Log.RotateSize,
|
|
Deprecated: "use --log.max-size",
|
|
}
|
|
legacyVerbosityFlag = cli.IntFlag{
|
|
Name: "verbosity",
|
|
Usage: "logging verbosity: 0=silent, 1=error, 2=warn, 3=info, 4=debug, 5=detail",
|
|
DefValue: defaultConfig.Log.Verbosity,
|
|
Deprecated: "use --log.verbosity",
|
|
}
|
|
)
|
|
|
|
func applyLogFlags(cmd *cobra.Command, config *harmonyconfig.HarmonyConfig) {
|
|
if cli.IsFlagChanged(cmd, logFolderFlag) {
|
|
config.Log.Folder = cli.GetStringFlagValue(cmd, logFolderFlag)
|
|
} else if cli.IsFlagChanged(cmd, legacyLogFolderFlag) {
|
|
config.Log.Folder = cli.GetStringFlagValue(cmd, legacyLogFolderFlag)
|
|
}
|
|
|
|
if cli.IsFlagChanged(cmd, logRotateSizeFlag) {
|
|
config.Log.RotateSize = cli.GetIntFlagValue(cmd, logRotateSizeFlag)
|
|
} else if cli.IsFlagChanged(cmd, legacyLogRotateSizeFlag) {
|
|
config.Log.RotateSize = cli.GetIntFlagValue(cmd, legacyLogRotateSizeFlag)
|
|
}
|
|
|
|
if cli.IsFlagChanged(cmd, logFileNameFlag) {
|
|
config.Log.FileName = cli.GetStringFlagValue(cmd, logFileNameFlag)
|
|
}
|
|
|
|
if cli.IsFlagChanged(cmd, logVerbosityFlag) {
|
|
config.Log.Verbosity = cli.GetIntFlagValue(cmd, logVerbosityFlag)
|
|
} else if cli.IsFlagChanged(cmd, legacyVerbosityFlag) {
|
|
config.Log.Verbosity = cli.GetIntFlagValue(cmd, legacyVerbosityFlag)
|
|
}
|
|
|
|
if cli.IsFlagChanged(cmd, logVerbosePrintsFlag) {
|
|
verbosePrintsFlagSlice := cli.GetStringSliceFlagValue(cmd, logVerbosePrintsFlag)
|
|
config.Log.VerbosePrints = harmonyconfig.FlagSliceToLogVerbosePrints(verbosePrintsFlagSlice)
|
|
}
|
|
|
|
if cli.HasFlagsChanged(cmd, []cli.Flag{logContextIPFlag, logContextPortFlag}) {
|
|
ctx := getDefaultLogContextCopy()
|
|
config.Log.Context = &ctx
|
|
|
|
if cli.IsFlagChanged(cmd, logContextIPFlag) {
|
|
config.Log.Context.IP = cli.GetStringFlagValue(cmd, logContextIPFlag)
|
|
}
|
|
if cli.IsFlagChanged(cmd, logContextPortFlag) {
|
|
config.Log.Context.Port = cli.GetIntFlagValue(cmd, logContextPortFlag)
|
|
}
|
|
}
|
|
}
|
|
|
|
var (
|
|
sysNtpServerFlag = cli.StringFlag{
|
|
Name: "sys.ntp",
|
|
Usage: "the ntp server",
|
|
DefValue: defaultSysConfig.NtpServer,
|
|
Hidden: true,
|
|
}
|
|
)
|
|
|
|
func applySysFlags(cmd *cobra.Command, config *harmonyconfig.HarmonyConfig) {
|
|
if cli.HasFlagsChanged(cmd, sysFlags) || config.Sys == nil {
|
|
cfg := getDefaultSysConfigCopy()
|
|
config.Sys = &cfg
|
|
}
|
|
|
|
if cli.IsFlagChanged(cmd, sysNtpServerFlag) {
|
|
config.Sys.NtpServer = cli.GetStringFlagValue(cmd, sysNtpServerFlag)
|
|
}
|
|
}
|
|
|
|
var (
|
|
devnetNumShardsFlag = cli.IntFlag{
|
|
Name: "devnet.num-shard",
|
|
Usage: "number of shards for devnet",
|
|
DefValue: defaultDevnetConfig.NumShards,
|
|
Hidden: true,
|
|
}
|
|
devnetShardSizeFlag = cli.IntFlag{
|
|
Name: "devnet.shard-size",
|
|
Usage: "number of nodes per shard for devnet",
|
|
DefValue: defaultDevnetConfig.ShardSize,
|
|
Hidden: true,
|
|
}
|
|
devnetHmyNodeSizeFlag = cli.IntFlag{
|
|
Name: "devnet.hmy-node-size",
|
|
Usage: "number of Harmony-operated nodes per shard for devnet (negative means equal to --devnet.shard-size)",
|
|
DefValue: defaultDevnetConfig.HmyNodeSize,
|
|
Hidden: true,
|
|
}
|
|
legacyDevnetNumShardsFlag = cli.IntFlag{
|
|
Name: "dn_num_shards",
|
|
Usage: "number of shards for -network_type=devnet",
|
|
DefValue: defaultDevnetConfig.NumShards,
|
|
Deprecated: "use --devnet.num-shard",
|
|
}
|
|
legacyDevnetShardSizeFlag = cli.IntFlag{
|
|
Name: "dn_shard_size",
|
|
Usage: "number of nodes per shard for -network_type=devnet",
|
|
DefValue: defaultDevnetConfig.ShardSize,
|
|
Deprecated: "use --devnet.shard-size",
|
|
}
|
|
legacyDevnetHmyNodeSizeFlag = cli.IntFlag{
|
|
Name: "dn_hmy_size",
|
|
Usage: "number of Harmony-operated nodes per shard for -network_type=devnet; negative means equal to -dn_shard_size",
|
|
DefValue: defaultDevnetConfig.HmyNodeSize,
|
|
Deprecated: "use --devnet.hmy-node-size",
|
|
}
|
|
)
|
|
|
|
func applyDevnetFlags(cmd *cobra.Command, config *harmonyconfig.HarmonyConfig) {
|
|
if cli.HasFlagsChanged(cmd, devnetFlags) && config.Devnet == nil {
|
|
cfg := getDefaultDevnetConfigCopy()
|
|
config.Devnet = &cfg
|
|
}
|
|
|
|
if cli.HasFlagsChanged(cmd, newDevnetFlags) {
|
|
if cli.IsFlagChanged(cmd, devnetNumShardsFlag) {
|
|
config.Devnet.NumShards = cli.GetIntFlagValue(cmd, devnetNumShardsFlag)
|
|
}
|
|
if cli.IsFlagChanged(cmd, devnetShardSizeFlag) {
|
|
config.Devnet.ShardSize = cli.GetIntFlagValue(cmd, devnetShardSizeFlag)
|
|
}
|
|
if cli.IsFlagChanged(cmd, devnetHmyNodeSizeFlag) {
|
|
config.Devnet.HmyNodeSize = cli.GetIntFlagValue(cmd, devnetHmyNodeSizeFlag)
|
|
}
|
|
}
|
|
if cli.HasFlagsChanged(cmd, legacyDevnetFlags) {
|
|
if cli.IsFlagChanged(cmd, legacyDevnetNumShardsFlag) {
|
|
config.Devnet.NumShards = cli.GetIntFlagValue(cmd, legacyDevnetNumShardsFlag)
|
|
}
|
|
if cli.IsFlagChanged(cmd, legacyDevnetShardSizeFlag) {
|
|
config.Devnet.ShardSize = cli.GetIntFlagValue(cmd, legacyDevnetShardSizeFlag)
|
|
}
|
|
if cli.IsFlagChanged(cmd, legacyDevnetHmyNodeSizeFlag) {
|
|
config.Devnet.HmyNodeSize = cli.GetIntFlagValue(cmd, legacyDevnetHmyNodeSizeFlag)
|
|
}
|
|
}
|
|
|
|
if config.Devnet != nil {
|
|
if config.Devnet.HmyNodeSize < 0 || config.Devnet.HmyNodeSize > config.Devnet.ShardSize {
|
|
config.Devnet.HmyNodeSize = config.Devnet.ShardSize
|
|
}
|
|
}
|
|
}
|
|
|
|
var (
|
|
revertBeaconFlag = cli.BoolFlag{
|
|
Name: "revert.beacon",
|
|
Usage: "revert the beacon chain",
|
|
DefValue: defaultRevertConfig.RevertBeacon,
|
|
Hidden: true,
|
|
}
|
|
revertToFlag = cli.IntFlag{
|
|
Name: "revert.to",
|
|
Usage: "rollback all blocks until and including block number revert.to",
|
|
DefValue: defaultRevertConfig.RevertTo,
|
|
Hidden: true,
|
|
}
|
|
revertBeforeFlag = cli.IntFlag{
|
|
Name: "revert.do-before",
|
|
Usage: "if the current block is less than revert.do-before, revert all blocks until (including) revert_to block",
|
|
DefValue: defaultRevertConfig.RevertBefore,
|
|
Hidden: true,
|
|
}
|
|
legacyRevertBeaconFlag = cli.BoolFlag{
|
|
Name: "revert_beacon",
|
|
Usage: "whether to revert beacon chain or the chain this node is assigned to",
|
|
DefValue: defaultRevertConfig.RevertBeacon,
|
|
Deprecated: "use --revert.beacon",
|
|
}
|
|
legacyRevertBeforeFlag = cli.IntFlag{
|
|
Name: "do_revert_before",
|
|
Usage: "If the current block is less than do_revert_before, revert all blocks until (including) revert_to block",
|
|
DefValue: defaultRevertConfig.RevertBefore,
|
|
Deprecated: "use --revert.do-before",
|
|
}
|
|
legacyRevertToFlag = cli.IntFlag{
|
|
Name: "revert_to",
|
|
Usage: "The revert will rollback all blocks until and including block number revert_to",
|
|
DefValue: defaultRevertConfig.RevertTo,
|
|
Deprecated: "use --revert.to",
|
|
}
|
|
)
|
|
|
|
func applyRevertFlags(cmd *cobra.Command, config *harmonyconfig.HarmonyConfig) {
|
|
if cli.HasFlagsChanged(cmd, revertFlags) {
|
|
cfg := getDefaultRevertConfigCopy()
|
|
config.Revert = &cfg
|
|
}
|
|
|
|
if cli.HasFlagsChanged(cmd, newRevertFlags) {
|
|
if cli.IsFlagChanged(cmd, revertBeaconFlag) {
|
|
config.Revert.RevertBeacon = cli.GetBoolFlagValue(cmd, revertBeaconFlag)
|
|
}
|
|
if cli.IsFlagChanged(cmd, revertBeforeFlag) {
|
|
config.Revert.RevertBefore = cli.GetIntFlagValue(cmd, revertBeforeFlag)
|
|
}
|
|
if cli.IsFlagChanged(cmd, revertToFlag) {
|
|
config.Revert.RevertTo = cli.GetIntFlagValue(cmd, revertToFlag)
|
|
}
|
|
}
|
|
|
|
if cli.HasFlagsChanged(cmd, legacyRevertFlags) {
|
|
if cli.IsFlagChanged(cmd, legacyRevertBeaconFlag) {
|
|
config.Revert.RevertBeacon = cli.GetBoolFlagValue(cmd, legacyRevertBeaconFlag)
|
|
}
|
|
if cli.IsFlagChanged(cmd, legacyRevertBeforeFlag) {
|
|
config.Revert.RevertBefore = cli.GetIntFlagValue(cmd, legacyRevertBeforeFlag)
|
|
}
|
|
if cli.IsFlagChanged(cmd, legacyRevertToFlag) {
|
|
config.Revert.RevertTo = cli.GetIntFlagValue(cmd, legacyRevertToFlag)
|
|
}
|
|
}
|
|
}
|
|
|
|
var (
|
|
legacyPortFlag = cli.IntFlag{
|
|
Name: "port",
|
|
Usage: "port of the node",
|
|
DefValue: defaultConfig.P2P.Port,
|
|
Deprecated: "Use --p2p.port, --http.port instead",
|
|
}
|
|
legacyIPFlag = cli.StringFlag{
|
|
Name: "ip",
|
|
Usage: "ip of the node",
|
|
DefValue: defaultConfig.HTTP.IP,
|
|
Deprecated: "use --http.ip",
|
|
}
|
|
legacyPublicRPCFlag = cli.BoolFlag{
|
|
Name: "public_rpc",
|
|
Usage: "Enable Public HTTP Access (default: false)",
|
|
DefValue: defaultConfig.HTTP.Enabled,
|
|
Deprecated: "use --http.ip and --ws.ip to specify the ip address to listen. Use 127.0.0.1 to listen local requests.",
|
|
}
|
|
legacyWebHookConfigFlag = cli.StringFlag{
|
|
Name: "webhook_yaml",
|
|
Usage: "path for yaml config reporting double signing",
|
|
DefValue: "",
|
|
Hidden: true,
|
|
}
|
|
legacyTPBroadcastInvalidTxFlag = cli.BoolFlag{
|
|
Name: "broadcast_invalid_tx",
|
|
Usage: "broadcast invalid transactions to sync pool state",
|
|
DefValue: defaultBroadcastInvalidTx,
|
|
Deprecated: "use --txpool.broadcast-invalid-tx",
|
|
}
|
|
)
|
|
|
|
// Note: this function need to be called before parse other flags
|
|
func applyLegacyMiscFlags(cmd *cobra.Command, config *harmonyconfig.HarmonyConfig) {
|
|
if cli.IsFlagChanged(cmd, legacyPortFlag) {
|
|
legacyPort := cli.GetIntFlagValue(cmd, legacyPortFlag)
|
|
config.P2P.Port = legacyPort
|
|
config.HTTP.Port = nodeconfig.GetRPCHTTPPortFromBase(legacyPort)
|
|
config.HTTP.RosettaPort = nodeconfig.GetRosettaHTTPPortFromBase(legacyPort)
|
|
config.WS.Port = nodeconfig.GetWSPortFromBase(legacyPort)
|
|
|
|
legPortStr := strconv.Itoa(legacyPort)
|
|
syncPort, _ := strconv.Atoi(legacysync.GetSyncingPort(legPortStr))
|
|
config.DNSSync.Port = syncPort
|
|
config.DNSSync.ServerPort = syncPort
|
|
}
|
|
|
|
if cli.IsFlagChanged(cmd, legacyIPFlag) {
|
|
// legacy IP is not used for listening port
|
|
config.HTTP.Enabled = true
|
|
config.WS.Enabled = true
|
|
}
|
|
|
|
if cli.IsFlagChanged(cmd, legacyPublicRPCFlag) {
|
|
if !cli.GetBoolFlagValue(cmd, legacyPublicRPCFlag) {
|
|
config.HTTP.IP = nodeconfig.DefaultLocalListenIP
|
|
config.WS.IP = nodeconfig.DefaultLocalListenIP
|
|
} else {
|
|
config.HTTP.IP = nodeconfig.DefaultPublicListenIP
|
|
config.WS.IP = nodeconfig.DefaultPublicListenIP
|
|
}
|
|
}
|
|
|
|
if cli.HasFlagsChanged(cmd, []cli.Flag{legacyPortFlag, legacyIPFlag}) {
|
|
logIP := cli.GetStringFlagValue(cmd, legacyIPFlag)
|
|
logPort := cli.GetIntFlagValue(cmd, legacyPortFlag)
|
|
config.Log.FileName = fmt.Sprintf("validator-%v-%v.log", logIP, logPort)
|
|
|
|
logCtx := &harmonyconfig.LogContext{
|
|
IP: logIP,
|
|
Port: logPort,
|
|
}
|
|
config.Log.Context = logCtx
|
|
}
|
|
|
|
if cli.HasFlagsChanged(cmd, []cli.Flag{legacyWebHookConfigFlag, legacyTPBroadcastInvalidTxFlag}) {
|
|
config.Legacy = &harmonyconfig.LegacyConfig{}
|
|
if cli.IsFlagChanged(cmd, legacyWebHookConfigFlag) {
|
|
val := cli.GetStringFlagValue(cmd, legacyWebHookConfigFlag)
|
|
config.Legacy.WebHookConfig = &val
|
|
}
|
|
if cli.IsFlagChanged(cmd, legacyTPBroadcastInvalidTxFlag) {
|
|
val := cli.GetBoolFlagValue(cmd, legacyTPBroadcastInvalidTxFlag)
|
|
config.Legacy.TPBroadcastInvalidTxn = &val
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
var (
|
|
prometheusEnabledFlag = cli.BoolFlag{
|
|
Name: "prometheus",
|
|
Usage: "enable HTTP / Prometheus requests",
|
|
DefValue: defaultPrometheusConfig.Enabled,
|
|
}
|
|
prometheusIPFlag = cli.StringFlag{
|
|
Name: "prometheus.ip",
|
|
Usage: "ip address to listen for prometheus service",
|
|
DefValue: defaultPrometheusConfig.IP,
|
|
}
|
|
prometheusPortFlag = cli.IntFlag{
|
|
Name: "prometheus.port",
|
|
Usage: "prometheus port to listen for HTTP requests",
|
|
DefValue: defaultPrometheusConfig.Port,
|
|
}
|
|
prometheusGatewayFlag = cli.StringFlag{
|
|
Name: "prometheus.pushgateway",
|
|
Usage: "prometheus pushgateway URL",
|
|
DefValue: defaultPrometheusConfig.Gateway,
|
|
}
|
|
prometheusEnablePushFlag = cli.BoolFlag{
|
|
Name: "prometheus.push",
|
|
Usage: "enable prometheus pushgateway",
|
|
DefValue: defaultPrometheusConfig.EnablePush,
|
|
}
|
|
)
|
|
|
|
func applyPrometheusFlags(cmd *cobra.Command, config *harmonyconfig.HarmonyConfig) {
|
|
if config.Prometheus == nil {
|
|
cfg := getDefaultPrometheusConfigCopy()
|
|
config.Prometheus = &cfg
|
|
// enable pushgateway for mainnet nodes by default
|
|
if config.Network.NetworkType == "mainnet" {
|
|
config.Prometheus.EnablePush = true
|
|
}
|
|
}
|
|
|
|
if cli.IsFlagChanged(cmd, prometheusIPFlag) {
|
|
config.Prometheus.IP = cli.GetStringFlagValue(cmd, prometheusIPFlag)
|
|
}
|
|
|
|
if cli.IsFlagChanged(cmd, prometheusPortFlag) {
|
|
config.Prometheus.Port = cli.GetIntFlagValue(cmd, prometheusPortFlag)
|
|
}
|
|
|
|
if cli.IsFlagChanged(cmd, prometheusEnabledFlag) {
|
|
config.Prometheus.Enabled = cli.GetBoolFlagValue(cmd, prometheusEnabledFlag)
|
|
}
|
|
|
|
if cli.IsFlagChanged(cmd, prometheusGatewayFlag) {
|
|
config.Prometheus.Gateway = cli.GetStringFlagValue(cmd, prometheusGatewayFlag)
|
|
}
|
|
if cli.IsFlagChanged(cmd, prometheusEnablePushFlag) {
|
|
config.Prometheus.EnablePush = cli.GetBoolFlagValue(cmd, prometheusEnablePushFlag)
|
|
}
|
|
}
|
|
|
|
var (
|
|
syncStreamEnabledFlag = cli.BoolFlag{
|
|
Name: "sync",
|
|
Usage: "Enable the stream sync protocol (experimental feature)",
|
|
DefValue: false,
|
|
}
|
|
// TODO: Deprecate this flag, and always set to true after stream sync is fully up.
|
|
syncDownloaderFlag = cli.BoolFlag{
|
|
Name: "sync.downloader",
|
|
Usage: "Enable the downloader module to sync through stream sync protocol",
|
|
Hidden: true,
|
|
DefValue: false,
|
|
}
|
|
syncConcurrencyFlag = cli.IntFlag{
|
|
Name: "sync.concurrency",
|
|
Usage: "Concurrency when doing p2p sync requests",
|
|
Hidden: true,
|
|
}
|
|
syncMinPeersFlag = cli.IntFlag{
|
|
Name: "sync.min-peers",
|
|
Usage: "Minimum peers check for each shard-wise sync loop",
|
|
Hidden: true,
|
|
}
|
|
syncInitStreamsFlag = cli.IntFlag{
|
|
Name: "sync.init-peers",
|
|
Usage: "Initial shard-wise number of peers to start syncing",
|
|
Hidden: true,
|
|
}
|
|
syncDiscSoftLowFlag = cli.IntFlag{
|
|
Name: "sync.disc.soft-low-cap",
|
|
Usage: "Soft low cap for sync stream management",
|
|
Hidden: true,
|
|
}
|
|
syncDiscHardLowFlag = cli.IntFlag{
|
|
Name: "sync.disc.hard-low-cap",
|
|
Usage: "Hard low cap for sync stream management",
|
|
Hidden: true,
|
|
}
|
|
syncDiscHighFlag = cli.IntFlag{
|
|
Name: "sync.disc.hi-cap",
|
|
Usage: "High cap for sync stream management",
|
|
Hidden: true,
|
|
}
|
|
syncDiscBatchFlag = cli.IntFlag{
|
|
Name: "sync.disc.batch",
|
|
Usage: "batch size of the sync discovery",
|
|
Hidden: true,
|
|
}
|
|
)
|
|
|
|
// applySyncFlags apply the sync flags.
|
|
func applySyncFlags(cmd *cobra.Command, config *harmonyconfig.HarmonyConfig) {
|
|
if cli.IsFlagChanged(cmd, syncStreamEnabledFlag) {
|
|
config.Sync.Enabled = cli.GetBoolFlagValue(cmd, syncStreamEnabledFlag)
|
|
}
|
|
|
|
if cli.IsFlagChanged(cmd, syncDownloaderFlag) {
|
|
config.Sync.Downloader = cli.GetBoolFlagValue(cmd, syncDownloaderFlag)
|
|
}
|
|
|
|
if cli.IsFlagChanged(cmd, syncConcurrencyFlag) {
|
|
config.Sync.Concurrency = cli.GetIntFlagValue(cmd, syncConcurrencyFlag)
|
|
}
|
|
|
|
if cli.IsFlagChanged(cmd, syncMinPeersFlag) {
|
|
config.Sync.MinPeers = cli.GetIntFlagValue(cmd, syncMinPeersFlag)
|
|
}
|
|
|
|
if cli.IsFlagChanged(cmd, syncInitStreamsFlag) {
|
|
config.Sync.InitStreams = cli.GetIntFlagValue(cmd, syncInitStreamsFlag)
|
|
}
|
|
|
|
if cli.IsFlagChanged(cmd, syncDiscSoftLowFlag) {
|
|
config.Sync.DiscSoftLowCap = cli.GetIntFlagValue(cmd, syncDiscSoftLowFlag)
|
|
}
|
|
|
|
if cli.IsFlagChanged(cmd, syncDiscHardLowFlag) {
|
|
config.Sync.DiscHardLowCap = cli.GetIntFlagValue(cmd, syncDiscHardLowFlag)
|
|
}
|
|
|
|
if cli.IsFlagChanged(cmd, syncDiscHighFlag) {
|
|
config.Sync.DiscHighCap = cli.GetIntFlagValue(cmd, syncDiscHighFlag)
|
|
}
|
|
|
|
if cli.IsFlagChanged(cmd, syncDiscBatchFlag) {
|
|
config.Sync.DiscBatch = cli.GetIntFlagValue(cmd, syncDiscBatchFlag)
|
|
}
|
|
}
|
|
|