diff --git a/CHANGELOG_PENDING.md b/CHANGELOG_PENDING.md index 13aff13a2..03891be43 100644 --- a/CHANGELOG_PENDING.md +++ b/CHANGELOG_PENDING.md @@ -12,6 +12,7 @@ Friendly reminder, we have a [bug bounty program](https://hackerone.com/tendermi - [config] \#5598 The `test_fuzz` and `test_fuzz_config` P2P settings have been removed. (@erikgrinaker) - [config] \#5728 `fast_sync = "v1"` is no longer supported (@melekes) - [cli] \#5772 `gen_node_key` prints JSON-encoded `NodeKey` rather than ID and does not save it to `node_key.json` (@melekes) + - [cli] \#5777 use hypen-case instead of snake_case for all cli comamnds and config parameters - Apps - [ABCI] \#5447 Remove `SetOption` method from `ABCI.Client` interface diff --git a/DOCKER/Dockerfile b/DOCKER/Dockerfile index 67aa3663f..a4ce89e47 100644 --- a/DOCKER/Dockerfile +++ b/DOCKER/Dockerfile @@ -40,7 +40,7 @@ ENV PROXY_APP=kvstore MONIKER=dockernode CHAIN_ID=dockerchain COPY ./docker-entrypoint.sh /usr/local/bin/ ENTRYPOINT ["docker-entrypoint.sh"] -CMD ["node"] +CMD ["start"] # Expose the data directory as a volume since there's mutable state in there VOLUME [ "$TMHOME" ] diff --git a/DOCKER/docker-entrypoint.sh b/DOCKER/docker-entrypoint.sh index 0cb45c58a..d74511c17 100755 --- a/DOCKER/docker-entrypoint.sh +++ b/DOCKER/docker-entrypoint.sh @@ -6,11 +6,11 @@ if [ ! -d "$TMHOME/config" ]; then tendermint init sed -i \ - -e "s/^proxy_app\s*=.*/proxy_app = \"$PROXY_APP\"/" \ + -e "s/^proxy-app\s*=.*/proxy-app = \"$PROXY_APP\"/" \ -e "s/^moniker\s*=.*/moniker = \"$MONIKER\"/" \ - -e 's/^addr_book_strict\s*=.*/addr_book_strict = false/' \ - -e 's/^timeout_commit\s*=.*/timeout_commit = "500ms"/' \ - -e 's/^index_all_tags\s*=.*/index_all_tags = true/' \ + -e 's/^addr-book-strict\s*=.*/addr-book-strict = false/' \ + -e 's/^timeout-commit\s*=.*/timeout-commit = "500ms"/' \ + -e 's/^index-all-tags\s*=.*/index-all-tags = true/' \ -e 's,^laddr = "tcp://127.0.0.1:26657",laddr = "tcp://0.0.0.0:26657",' \ -e 's/^prometheus\s*=.*/prometheus = true/' \ "$TMHOME/config/config.toml" diff --git a/UPGRADING.md b/UPGRADING.md index db38f0a85..a6ce485d2 100644 --- a/UPGRADING.md +++ b/UPGRADING.md @@ -14,6 +14,9 @@ This guide provides instructions for upgrading to specific versions of Tendermin * `fast_sync = "v1"` is no longer supported. Please use `v2` instead. +* All config parameters are now hyphen-case (also known as kebab-case) instead of snake_case. Before restarting the node make sure + you have updated all the variables in your `config.toml` file. + ### CLI Changes * If you had previously used `tendermint gen_node_key` to generate a new node @@ -25,6 +28,8 @@ This guide provides instructions for upgrading to specific versions of Tendermin $ tendermint gen_node_key > $TMHOME/config/node_key.json ``` +* CLI commands and flags are all now hyphen-case instead of snake_case. + Make sure to adjust any scripts that calls a cli command with snake_casing ## v0.34.0 **Upgrading to Tendermint 0.34 requires a blockchain restart.** diff --git a/cmd/tendermint/commands/gen_node_key.go b/cmd/tendermint/commands/gen_node_key.go index bfcf05674..3216a6256 100644 --- a/cmd/tendermint/commands/gen_node_key.go +++ b/cmd/tendermint/commands/gen_node_key.go @@ -12,9 +12,11 @@ import ( // GenNodeKeyCmd allows the generation of a node key. It prints JSON-encoded // NodeKey to the standard output. var GenNodeKeyCmd = &cobra.Command{ - Use: "gen_node_key", - Short: "Generate new node key", - RunE: genNodeKey, + Use: "gen-node-key", + Aliases: []string{"gen_node_key"}, + Short: "Generate a new node key", + RunE: genNodeKey, + PreRun: deprecateSnakeCase, } func genNodeKey(cmd *cobra.Command, args []string) error { diff --git a/cmd/tendermint/commands/gen_validator.go b/cmd/tendermint/commands/gen_validator.go index 9620e0004..09f84b09e 100644 --- a/cmd/tendermint/commands/gen_validator.go +++ b/cmd/tendermint/commands/gen_validator.go @@ -13,9 +13,11 @@ import ( // GenValidatorCmd allows the generation of a keypair for a // validator. var GenValidatorCmd = &cobra.Command{ - Use: "gen_validator", - Short: "Generate new validator keypair", - RunE: genValidator, + Use: "gen-validator", + Aliases: []string{"gen_validator"}, + Short: "Generate new validator keypair", + RunE: genValidator, + PreRun: deprecateSnakeCase, } func init() { diff --git a/cmd/tendermint/commands/light.go b/cmd/tendermint/commands/light.go index 85c94118f..dcf89fc6d 100644 --- a/cmd/tendermint/commands/light.go +++ b/cmd/tendermint/commands/light.go @@ -61,7 +61,7 @@ var ( primaryAddr string witnessAddrsJoined string chainID string - home string + dir string maxOpenConnections int sequential bool @@ -83,8 +83,8 @@ func init() { "connect to a Tendermint node at this address") LightCmd.Flags().StringVarP(&witnessAddrsJoined, "witnesses", "w", "", "tendermint nodes to cross-check the primary node, comma-separated") - LightCmd.Flags().StringVar(&home, "home-dir", os.ExpandEnv(filepath.Join("$HOME", ".tendermint-light")), - "specify the home directory") + LightCmd.Flags().StringVarP(&dir, "dir", "d", os.ExpandEnv(filepath.Join("$HOME", ".tendermint-light")), + "specify the directory") LightCmd.Flags().IntVar( &maxOpenConnections, "max-open-connections", @@ -122,7 +122,7 @@ func runProxy(cmd *cobra.Command, args []string) error { witnessesAddrs = strings.Split(witnessAddrsJoined, ",") } - db, err := dbm.NewGoLevelDB("light-client-db", home) + db, err := dbm.NewGoLevelDB("light-client-db", dir) if err != nil { return fmt.Errorf("can't create a db: %w", err) } diff --git a/cmd/tendermint/commands/probe_upnp.go b/cmd/tendermint/commands/probe_upnp.go index 9ac35fd50..7d0193c84 100644 --- a/cmd/tendermint/commands/probe_upnp.go +++ b/cmd/tendermint/commands/probe_upnp.go @@ -11,9 +11,11 @@ import ( // ProbeUpnpCmd adds capabilities to test the UPnP functionality. var ProbeUpnpCmd = &cobra.Command{ - Use: "probe_upnp", - Short: "Test UPnP functionality", - RunE: probeUpnp, + Use: "probe-upnp", + Aliases: []string{"probe_upnp"}, + Short: "Test UPnP functionality", + RunE: probeUpnp, + PreRun: deprecateSnakeCase, } func probeUpnp(cmd *cobra.Command, args []string) error { diff --git a/cmd/tendermint/commands/replay.go b/cmd/tendermint/commands/replay.go index 303ccba6b..5de8d0d3e 100644 --- a/cmd/tendermint/commands/replay.go +++ b/cmd/tendermint/commands/replay.go @@ -18,9 +18,11 @@ var ReplayCmd = &cobra.Command{ // ReplayConsoleCmd allows replaying of messages from the WAL in a // console. var ReplayConsoleCmd = &cobra.Command{ - Use: "replay_console", - Short: "Replay messages from WAL in a console", + Use: "replay-console", + Aliases: []string{"replay_console"}, + Short: "Replay messages from WAL in a console", Run: func(cmd *cobra.Command, args []string) { consensus.RunReplayFile(config.BaseConfig, config.Consensus, true) }, + PreRun: deprecateSnakeCase, } diff --git a/cmd/tendermint/commands/reset_priv_validator.go b/cmd/tendermint/commands/reset_priv_validator.go index 79799a2ed..3f0b51653 100644 --- a/cmd/tendermint/commands/reset_priv_validator.go +++ b/cmd/tendermint/commands/reset_priv_validator.go @@ -14,9 +14,11 @@ import ( // ResetAllCmd removes the database of this Tendermint core // instance. var ResetAllCmd = &cobra.Command{ - Use: "unsafe_reset_all", - Short: "(unsafe) Remove all the data and WAL, reset this node's validator to genesis state", - Run: resetAll, + Use: "unsafe-reset-all", + Aliases: []string{"unsafe_reset_all"}, + Short: "(unsafe) Remove all the data and WAL, reset this node's validator to genesis state", + Run: resetAll, + PreRun: deprecateSnakeCase, } var keepAddrBook bool @@ -29,9 +31,11 @@ func init() { // ResetPrivValidatorCmd resets the private validator files. var ResetPrivValidatorCmd = &cobra.Command{ - Use: "unsafe_reset_priv_validator", - Short: "(unsafe) Reset this node's validator to genesis state", - Run: resetPrivValidator, + Use: "unsafe-reset-priv-validator", + Aliases: []string{"unsafe_reset_priv_validator"}, + Short: "(unsafe) Reset this node's validator to genesis state", + Run: resetPrivValidator, + PreRun: deprecateSnakeCase, } // XXX: this is totally unsafe. diff --git a/cmd/tendermint/commands/root.go b/cmd/tendermint/commands/root.go index 664f8ff14..41aa97d83 100644 --- a/cmd/tendermint/commands/root.go +++ b/cmd/tendermint/commands/root.go @@ -3,6 +3,7 @@ package commands import ( "fmt" "os" + "strings" "github.com/spf13/cobra" "github.com/spf13/viper" @@ -23,7 +24,7 @@ func init() { } func registerFlagsRootCmd(cmd *cobra.Command) { - cmd.PersistentFlags().String("log_level", config.LogLevel, "log level") + cmd.PersistentFlags().String("log-level", config.LogLevel, "log level") } // ParseConfig retrieves the default environment configuration, @@ -36,16 +37,16 @@ func ParseConfig() (*cfg.Config, error) { } conf.SetRoot(conf.RootDir) cfg.EnsureRoot(conf.RootDir) - if err = conf.ValidateBasic(); err != nil { + if err := conf.ValidateBasic(); err != nil { return nil, fmt.Errorf("error in config file: %v", err) } - return conf, err + return conf, nil } // RootCmd is the root command for Tendermint core. var RootCmd = &cobra.Command{ Use: "tendermint", - Short: "Tendermint Core (BFT Consensus) in Go", + Short: "BFT state machine replication for applications in any programming languages", PersistentPreRunE: func(cmd *cobra.Command, args []string) (err error) { if cmd.Name() == VersionCmd.Name() { return nil @@ -68,3 +69,10 @@ var RootCmd = &cobra.Command{ return nil }, } + +// deprecateSnakeCase is a util function for 0.34.1. Should be removed in 0.35 +func deprecateSnakeCase(cmd *cobra.Command, args []string) { + if strings.Contains(cmd.CalledAs(), "_") { + fmt.Println("Deprecated: snake_case commands will be replaced by hyphen-case commands in the next major release") + } +} diff --git a/cmd/tendermint/commands/root_test.go b/cmd/tendermint/commands/root_test.go index d1e5964b2..2814435d0 100644 --- a/cmd/tendermint/commands/root_test.go +++ b/cmd/tendermint/commands/root_test.go @@ -99,7 +99,7 @@ func TestRootFlagsEnv(t *testing.T) { logLevel string }{ {[]string{"--log", "debug"}, nil, defaultLogLvl}, // wrong flag - {[]string{"--log_level", "debug"}, nil, "debug"}, // right flag + {[]string{"--log-level", "debug"}, nil, "debug"}, // right flag {nil, map[string]string{"TM_LOW": "debug"}, defaultLogLvl}, // wrong env flag {nil, map[string]string{"MT_LOG_LEVEL": "debug"}, defaultLogLvl}, // wrong env prefix {nil, map[string]string{"TM_LOG_LEVEL": "debug"}, "debug"}, // right env @@ -120,7 +120,7 @@ func TestRootConfig(t *testing.T) { // write non-default config nonDefaultLogLvl := "abc:debug" cvals := map[string]string{ - "log_level": nonDefaultLogLvl, + "log-level": nonDefaultLogLvl, } cases := []struct { @@ -130,7 +130,7 @@ func TestRootConfig(t *testing.T) { logLvl string }{ {nil, nil, nonDefaultLogLvl}, // should load config - {[]string{"--log_level=abc:info"}, nil, "abc:info"}, // flag over rides + {[]string{"--log-level=abc:info"}, nil, "abc:info"}, // flag over rides {nil, map[string]string{"TM_LOG_LEVEL": "abc:info"}, "abc:info"}, // env over rides } diff --git a/cmd/tendermint/commands/run_node.go b/cmd/tendermint/commands/run_node.go index af77553fa..f33ccdf46 100644 --- a/cmd/tendermint/commands/run_node.go +++ b/cmd/tendermint/commands/run_node.go @@ -26,24 +26,24 @@ func AddNodeFlags(cmd *cobra.Command) { // priv val flags cmd.Flags().String( - "priv_validator_laddr", + "priv-validator-laddr", config.PrivValidatorListenAddr, - "socket address to listen on for connections from external priv_validator process") + "socket address to listen on for connections from external priv-validator process") // node flags - cmd.Flags().Bool("fast_sync", config.FastSyncMode, "fast blockchain syncing") + cmd.Flags().Bool("fast-sync", config.FastSyncMode, "fast blockchain syncing") cmd.Flags().BytesHexVar( &genesisHash, - "genesis_hash", + "genesis-hash", []byte{}, "optional SHA-256 hash of the genesis file") - cmd.Flags().Int64("consensus.double_sign_check_height", config.Consensus.DoubleSignCheckHeight, + cmd.Flags().Int64("consensus.double-sign-check-height", config.Consensus.DoubleSignCheckHeight, "how many blocks to look back to check existence of the node's "+ "consensus votes before joining consensus") // abci flags cmd.Flags().String( - "proxy_app", + "proxy-app", config.ProxyApp, "proxy app address, or one of: 'kvstore',"+ " 'persistent_kvstore',"+ @@ -54,11 +54,11 @@ func AddNodeFlags(cmd *cobra.Command) { // rpc flags cmd.Flags().String("rpc.laddr", config.RPC.ListenAddress, "RPC listen address. Port required") cmd.Flags().String( - "rpc.grpc_laddr", + "rpc.grpc-laddr", config.RPC.GRPCListenAddress, "GRPC listen address (BroadcastTx only). Port required") cmd.Flags().Bool("rpc.unsafe", config.RPC.Unsafe, "enabled unsafe rpc methods") - cmd.Flags().String("rpc.pprof_laddr", config.RPC.PprofListenAddress, "pprof listen address (https://golang.org/pkg/net/http/pprof)") + cmd.Flags().String("rpc.pprof-laddr", config.RPC.PprofListenAddress, "pprof listen address (https://golang.org/pkg/net/http/pprof)") // p2p flags cmd.Flags().String( @@ -66,31 +66,31 @@ func AddNodeFlags(cmd *cobra.Command) { config.P2P.ListenAddress, "node listen address. (0.0.0.0:0 means any interface, any port)") cmd.Flags().String("p2p.seeds", config.P2P.Seeds, "comma-delimited ID@host:port seed nodes") - cmd.Flags().String("p2p.persistent_peers", config.P2P.PersistentPeers, "comma-delimited ID@host:port persistent peers") - cmd.Flags().String("p2p.unconditional_peer_ids", + cmd.Flags().String("p2p.persistent-peers", config.P2P.PersistentPeers, "comma-delimited ID@host:port persistent peers") + cmd.Flags().String("p2p.unconditional-peer-ids", config.P2P.UnconditionalPeerIDs, "comma-delimited IDs of unconditional peers") cmd.Flags().Bool("p2p.upnp", config.P2P.UPNP, "enable/disable UPNP port forwarding") cmd.Flags().Bool("p2p.pex", config.P2P.PexReactor, "enable/disable Peer-Exchange") - cmd.Flags().Bool("p2p.seed_mode", config.P2P.SeedMode, "enable/disable seed mode") - cmd.Flags().String("p2p.private_peer_ids", config.P2P.PrivatePeerIDs, "comma-delimited private peer IDs") + cmd.Flags().Bool("p2p.seed-mode", config.P2P.SeedMode, "enable/disable seed mode") + cmd.Flags().String("p2p.private-peer-ids", config.P2P.PrivatePeerIDs, "comma-delimited private peer IDs") // consensus flags cmd.Flags().Bool( - "consensus.create_empty_blocks", + "consensus.create-empty-blocks", config.Consensus.CreateEmptyBlocks, "set this to false to only produce blocks when there are txs or when the AppHash changes") cmd.Flags().String( - "consensus.create_empty_blocks_interval", + "consensus.create-empty-blocks-interval", config.Consensus.CreateEmptyBlocksInterval.String(), "the possible interval between empty blocks") // db flags cmd.Flags().String( - "db_backend", + "db-backend", config.DBBackend, "database backend: goleveldb | cleveldb | boltdb | rocksdb | badgerdb") cmd.Flags().String( - "db_dir", + "db-dir", config.DBPath, "database directory") } @@ -99,8 +99,9 @@ func AddNodeFlags(cmd *cobra.Command) { // It can be used with a custom PrivValidator and in-process ABCI application. func NewRunNodeCmd(nodeProvider nm.Provider) *cobra.Command { cmd := &cobra.Command{ - Use: "node", - Short: "Run the tendermint node", + Use: "start", + Aliases: []string{"node", "run"}, + Short: "Run the tendermint node", RunE: func(cmd *cobra.Command, args []string) error { if err := checkGenesisHash(config); err != nil { return err diff --git a/cmd/tendermint/commands/show_node_id.go b/cmd/tendermint/commands/show_node_id.go index ce2019a01..248afdd82 100644 --- a/cmd/tendermint/commands/show_node_id.go +++ b/cmd/tendermint/commands/show_node_id.go @@ -10,9 +10,11 @@ import ( // ShowNodeIDCmd dumps node's ID to the standard output. var ShowNodeIDCmd = &cobra.Command{ - Use: "show_node_id", - Short: "Show this node's ID", - RunE: showNodeID, + Use: "show-node-id", + Aliases: []string{"show_node_id"}, + Short: "Show this node's ID", + RunE: showNodeID, + PreRun: deprecateSnakeCase, } func showNodeID(cmd *cobra.Command, args []string) error { diff --git a/cmd/tendermint/commands/show_validator.go b/cmd/tendermint/commands/show_validator.go index e3980743a..f29976bb3 100644 --- a/cmd/tendermint/commands/show_validator.go +++ b/cmd/tendermint/commands/show_validator.go @@ -12,9 +12,11 @@ import ( // ShowValidatorCmd adds capabilities for showing the validator info. var ShowValidatorCmd = &cobra.Command{ - Use: "show_validator", - Short: "Show this node's validator info", - RunE: showValidator, + Use: "show-validator", + Aliases: []string{"show_validator"}, + Short: "Show this node's validator info", + RunE: showValidator, + PreRun: deprecateSnakeCase, } func showValidator(cmd *cobra.Command, args []string) error { diff --git a/cmd/tendermint/commands/testnet.go b/cmd/tendermint/commands/testnet.go index 0229092e0..3079a6992 100644 --- a/cmd/tendermint/commands/testnet.go +++ b/cmd/tendermint/commands/testnet.go @@ -88,7 +88,7 @@ necessary files (private validator, genesis, config, etc.). Note, strict routability for addresses is turned off in the config file. -Optionally, it will fill in persistent_peers list in config file using either hostnames or IPs. +Optionally, it will fill in persistent-peers list in config file using either hostnames or IPs. Example: diff --git a/config/config.go b/config/config.go index c7e012978..58187f1db 100644 --- a/config/config.go +++ b/config/config.go @@ -63,7 +63,7 @@ type Config struct { StateSync *StateSyncConfig `mapstructure:"statesync"` FastSync *FastSyncConfig `mapstructure:"fastsync"` Consensus *ConsensusConfig `mapstructure:"consensus"` - TxIndex *TxIndexConfig `mapstructure:"tx_index"` + TxIndex *TxIndexConfig `mapstructure:"tx-index"` Instrumentation *InstrumentationConfig `mapstructure:"instrumentation"` } @@ -151,7 +151,7 @@ type BaseConfig struct { //nolint: maligned // TCP or UNIX socket address of the ABCI application, // or the name of an ABCI application compiled in with the Tendermint binary - ProxyApp string `mapstructure:"proxy_app"` + ProxyApp string `mapstructure:"proxy-app"` // A custom human readable name for this node Moniker string `mapstructure:"moniker"` @@ -159,7 +159,7 @@ type BaseConfig struct { //nolint: maligned // If this node is many blocks behind the tip of the chain, FastSync // allows them to catchup quickly by downloading blocks in parallel // and verifying their commits - FastSyncMode bool `mapstructure:"fast_sync"` + FastSyncMode bool `mapstructure:"fast-sync"` // Database backend: goleveldb | cleveldb | boltdb | rocksdb // * goleveldb (github.com/syndtr/goleveldb - most popular implementation) @@ -180,39 +180,39 @@ type BaseConfig struct { //nolint: maligned // * badgerdb (uses github.com/dgraph-io/badger) // - EXPERIMENTAL // - use badgerdb build tag (go build -tags badgerdb) - DBBackend string `mapstructure:"db_backend"` + DBBackend string `mapstructure:"db-backend"` // Database directory - DBPath string `mapstructure:"db_dir"` + DBPath string `mapstructure:"db-dir"` // Output level for logging - LogLevel string `mapstructure:"log_level"` + LogLevel string `mapstructure:"log-level"` // Output format: 'plain' (colored text) or 'json' - LogFormat string `mapstructure:"log_format"` + LogFormat string `mapstructure:"log-format"` // Path to the JSON file containing the initial validator set and other meta data - Genesis string `mapstructure:"genesis_file"` + Genesis string `mapstructure:"genesis-file"` // Path to the JSON file containing the private key to use as a validator in the consensus protocol - PrivValidatorKey string `mapstructure:"priv_validator_key_file"` + PrivValidatorKey string `mapstructure:"priv-validator-key-file"` // Path to the JSON file containing the last sign state of a validator - PrivValidatorState string `mapstructure:"priv_validator_state_file"` + PrivValidatorState string `mapstructure:"priv-validator-state-file"` // TCP or UNIX socket address for Tendermint to listen on for // connections from an external PrivValidator process - PrivValidatorListenAddr string `mapstructure:"priv_validator_laddr"` + PrivValidatorListenAddr string `mapstructure:"priv-validator-laddr"` // A JSON file containing the private key to use for p2p authenticated encryption - NodeKey string `mapstructure:"node_key_file"` + NodeKey string `mapstructure:"node-key-file"` // Mechanism to connect to the ABCI application: socket | grpc ABCI string `mapstructure:"abci"` // If true, query the ABCI app on connecting to a new peer // so the app can decide if we should keep the connection or not - FilterPeers bool `mapstructure:"filter_peers"` // false + FilterPeers bool `mapstructure:"filter-peers"` // false } // DefaultBaseConfig returns a default base configuration for a Tendermint node @@ -279,7 +279,7 @@ func (cfg BaseConfig) ValidateBasic() error { switch cfg.LogFormat { case LogFormatPlain, LogFormatJSON: default: - return errors.New("unknown log_format (must be 'plain' or 'json')") + return errors.New("unknown log format (must be 'plain' or 'json')") } return nil } @@ -309,58 +309,58 @@ type RPCConfig struct { // If the special '*' value is present in the list, all origins will be allowed. // An origin may contain a wildcard (*) to replace 0 or more characters (i.e.: http://*.domain.com). // Only one wildcard can be used per origin. - CORSAllowedOrigins []string `mapstructure:"cors_allowed_origins"` + CORSAllowedOrigins []string `mapstructure:"cors-allowed-origins"` // A list of methods the client is allowed to use with cross-domain requests. - CORSAllowedMethods []string `mapstructure:"cors_allowed_methods"` + CORSAllowedMethods []string `mapstructure:"cors-allowed-methods"` // A list of non simple headers the client is allowed to use with cross-domain requests. - CORSAllowedHeaders []string `mapstructure:"cors_allowed_headers"` + CORSAllowedHeaders []string `mapstructure:"cors-allowed-headers"` // TCP or UNIX socket address for the gRPC server to listen on // NOTE: This server only supports /broadcast_tx_commit - GRPCListenAddress string `mapstructure:"grpc_laddr"` + GRPCListenAddress string `mapstructure:"grpc-laddr"` // Maximum number of simultaneous connections. - // Does not include RPC (HTTP&WebSocket) connections. See max_open_connections + // Does not include RPC (HTTP&WebSocket) connections. See max-open-connections // If you want to accept a larger number than the default, make sure // you increase your OS limits. // 0 - unlimited. - GRPCMaxOpenConnections int `mapstructure:"grpc_max_open_connections"` + GRPCMaxOpenConnections int `mapstructure:"grpc-max-open-connections"` - // Activate unsafe RPC commands like /dial_persistent_peers and /unsafe_flush_mempool + // Activate unsafe RPC commands like /dial-persistent-peers and /unsafe-flush-mempool Unsafe bool `mapstructure:"unsafe"` // Maximum number of simultaneous connections (including WebSocket). - // Does not include gRPC connections. See grpc_max_open_connections + // Does not include gRPC connections. See grpc-max-open-connections // If you want to accept a larger number than the default, make sure // you increase your OS limits. // 0 - unlimited. // Should be < {ulimit -Sn} - {MaxNumInboundPeers} - {MaxNumOutboundPeers} - {N of wal, db and other open files} // 1024 - 40 - 10 - 50 = 924 = ~900 - MaxOpenConnections int `mapstructure:"max_open_connections"` + MaxOpenConnections int `mapstructure:"max-open-connections"` // Maximum number of unique clientIDs that can /subscribe // If you're using /broadcast_tx_commit, set to the estimated maximum number // of broadcast_tx_commit calls per block. - MaxSubscriptionClients int `mapstructure:"max_subscription_clients"` + MaxSubscriptionClients int `mapstructure:"max-subscription-clients"` // Maximum number of unique queries a given client can /subscribe to // If you're using GRPC (or Local RPC client) and /broadcast_tx_commit, set // to the estimated maximum number of broadcast_tx_commit calls per block. - MaxSubscriptionsPerClient int `mapstructure:"max_subscriptions_per_client"` + MaxSubscriptionsPerClient int `mapstructure:"max-subscriptions-per-client"` // How long to wait for a tx to be committed during /broadcast_tx_commit // WARNING: Using a value larger than 10s will result in increasing the // global HTTP write timeout, which applies to all connections and endpoints. // See https://github.com/tendermint/tendermint/issues/3435 - TimeoutBroadcastTxCommit time.Duration `mapstructure:"timeout_broadcast_tx_commit"` + TimeoutBroadcastTxCommit time.Duration `mapstructure:"timeout-broadcast-tx-commit"` // Maximum size of request body, in bytes - MaxBodyBytes int64 `mapstructure:"max_body_bytes"` + MaxBodyBytes int64 `mapstructure:"max-body-bytes"` // Maximum size of request header, in bytes - MaxHeaderBytes int `mapstructure:"max_header_bytes"` + MaxHeaderBytes int `mapstructure:"max-header-bytes"` // The path to a file containing certificate that is used to create the HTTPS server. // Migth be either absolute path or path related to tendermint's config directory. @@ -369,19 +369,19 @@ type RPCConfig struct { // the certFile should be the concatenation of the server's certificate, any intermediates, // and the CA's certificate. // - // NOTE: both tls_cert_file and tls_key_file must be present for Tendermint to create HTTPS server. + // NOTE: both tls-cert-file and tls-key-file must be present for Tendermint to create HTTPS server. // Otherwise, HTTP server is run. - TLSCertFile string `mapstructure:"tls_cert_file"` + TLSCertFile string `mapstructure:"tls-cert-file"` // The path to a file containing matching private key that is used to create the HTTPS server. // Migth be either absolute path or path related to tendermint's config directory. // - // NOTE: both tls_cert_file and tls_key_file must be present for Tendermint to create HTTPS server. + // NOTE: both tls-cert-file and tls-key-file must be present for Tendermint to create HTTPS server. // Otherwise, HTTP server is run. - TLSKeyFile string `mapstructure:"tls_key_file"` + TLSKeyFile string `mapstructure:"tls-key-file"` // pprof listen address (https://golang.org/pkg/net/http/pprof) - PprofListenAddress string `mapstructure:"pprof_laddr"` + PprofListenAddress string `mapstructure:"pprof-laddr"` } // DefaultRPCConfig returns a default configuration for the RPC server @@ -422,25 +422,25 @@ func TestRPCConfig() *RPCConfig { // returns an error if any check fails. func (cfg *RPCConfig) ValidateBasic() error { if cfg.GRPCMaxOpenConnections < 0 { - return errors.New("grpc_max_open_connections can't be negative") + return errors.New("grpc-max-open-connections can't be negative") } if cfg.MaxOpenConnections < 0 { - return errors.New("max_open_connections can't be negative") + return errors.New("max-open-connections can't be negative") } if cfg.MaxSubscriptionClients < 0 { - return errors.New("max_subscription_clients can't be negative") + return errors.New("max-subscription-clients can't be negative") } if cfg.MaxSubscriptionsPerClient < 0 { - return errors.New("max_subscriptions_per_client can't be negative") + return errors.New("max-subscriptions-per-client can't be negative") } if cfg.TimeoutBroadcastTxCommit < 0 { - return errors.New("timeout_broadcast_tx_commit can't be negative") + return errors.New("timeout-broadcast-tx-commit can't be negative") } if cfg.MaxBodyBytes < 0 { - return errors.New("max_body_bytes can't be negative") + return errors.New("max-body-bytes can't be negative") } if cfg.MaxHeaderBytes < 0 { - return errors.New("max_header_bytes can't be negative") + return errors.New("max-header-bytes can't be negative") } return nil } @@ -481,48 +481,48 @@ type P2PConfig struct { //nolint: maligned ListenAddress string `mapstructure:"laddr"` // Address to advertise to peers for them to dial - ExternalAddress string `mapstructure:"external_address"` + ExternalAddress string `mapstructure:"external-address"` // Comma separated list of seed nodes to connect to // We only use these if we can’t connect to peers in the addrbook Seeds string `mapstructure:"seeds"` // Comma separated list of nodes to keep persistent connections to - PersistentPeers string `mapstructure:"persistent_peers"` + PersistentPeers string `mapstructure:"persistent-peers"` // UPNP port forwarding UPNP bool `mapstructure:"upnp"` // Path to address book - AddrBook string `mapstructure:"addr_book_file"` + AddrBook string `mapstructure:"addr-book-file"` // Set true for strict address routability rules // Set false for private or local networks - AddrBookStrict bool `mapstructure:"addr_book_strict"` + AddrBookStrict bool `mapstructure:"addr-book-strict"` // Maximum number of inbound peers - MaxNumInboundPeers int `mapstructure:"max_num_inbound_peers"` + MaxNumInboundPeers int `mapstructure:"max-num-inbound-peers"` // Maximum number of outbound peers to connect to, excluding persistent peers - MaxNumOutboundPeers int `mapstructure:"max_num_outbound_peers"` + MaxNumOutboundPeers int `mapstructure:"max-num-outbound-peers"` // List of node IDs, to which a connection will be (re)established ignoring any existing limits - UnconditionalPeerIDs string `mapstructure:"unconditional_peer_ids"` + UnconditionalPeerIDs string `mapstructure:"unconditional-peer-ids"` // Maximum pause when redialing a persistent peer (if zero, exponential backoff is used) - PersistentPeersMaxDialPeriod time.Duration `mapstructure:"persistent_peers_max_dial_period"` + PersistentPeersMaxDialPeriod time.Duration `mapstructure:"persistent-peers-max-dial-period"` // Time to wait before flushing messages out on the connection - FlushThrottleTimeout time.Duration `mapstructure:"flush_throttle_timeout"` + FlushThrottleTimeout time.Duration `mapstructure:"flush-throttle-timeout"` // Maximum size of a message packet payload, in bytes - MaxPacketMsgPayloadSize int `mapstructure:"max_packet_msg_payload_size"` + MaxPacketMsgPayloadSize int `mapstructure:"max-packet-msg-payload-size"` // Rate at which packets can be sent, in bytes/second - SendRate int64 `mapstructure:"send_rate"` + SendRate int64 `mapstructure:"send-rate"` // Rate at which packets can be received, in bytes/second - RecvRate int64 `mapstructure:"recv_rate"` + RecvRate int64 `mapstructure:"recv-rate"` // Set true to enable the peer-exchange reactor PexReactor bool `mapstructure:"pex"` @@ -531,22 +531,22 @@ type P2PConfig struct { //nolint: maligned // peers. If another node asks it for addresses, it responds and disconnects. // // Does not work if the peer-exchange reactor is disabled. - SeedMode bool `mapstructure:"seed_mode"` + SeedMode bool `mapstructure:"seed-mode"` // Comma separated list of peer IDs to keep private (will not be gossiped to // other peers) - PrivatePeerIDs string `mapstructure:"private_peer_ids"` + PrivatePeerIDs string `mapstructure:"private-peer-ids"` // Toggle to disable guard against peers connecting from the same ip. - AllowDuplicateIP bool `mapstructure:"allow_duplicate_ip"` + AllowDuplicateIP bool `mapstructure:"allow-duplicate-ip"` // Peer connection configuration. - HandshakeTimeout time.Duration `mapstructure:"handshake_timeout"` - DialTimeout time.Duration `mapstructure:"dial_timeout"` + HandshakeTimeout time.Duration `mapstructure:"handshake-timeout"` + DialTimeout time.Duration `mapstructure:"dial-timeout"` // Testing params. // Force dial to fail - TestDialFail bool `mapstructure:"test_dial_fail"` + TestDialFail bool `mapstructure:"test-dial-fail"` } // DefaultP2PConfig returns a default configuration for the peer-to-peer layer @@ -591,25 +591,25 @@ func (cfg *P2PConfig) AddrBookFile() string { // returns an error if any check fails. func (cfg *P2PConfig) ValidateBasic() error { if cfg.MaxNumInboundPeers < 0 { - return errors.New("max_num_inbound_peers can't be negative") + return errors.New("max-num-inbound-peers can't be negative") } if cfg.MaxNumOutboundPeers < 0 { - return errors.New("max_num_outbound_peers can't be negative") + return errors.New("max-num-outbound-peers can't be negative") } if cfg.FlushThrottleTimeout < 0 { - return errors.New("flush_throttle_timeout can't be negative") + return errors.New("flush-throttle-timeout can't be negative") } if cfg.PersistentPeersMaxDialPeriod < 0 { - return errors.New("persistent_peers_max_dial_period can't be negative") + return errors.New("persistent-peers-max-dial-period can't be negative") } if cfg.MaxPacketMsgPayloadSize < 0 { - return errors.New("max_packet_msg_payload_size can't be negative") + return errors.New("max-packet-msg-payload-size can't be negative") } if cfg.SendRate < 0 { - return errors.New("send_rate can't be negative") + return errors.New("send-rate can't be negative") } if cfg.RecvRate < 0 { - return errors.New("recv_rate can't be negative") + return errors.New("recv-rate can't be negative") } return nil } @@ -622,21 +622,21 @@ type MempoolConfig struct { RootDir string `mapstructure:"home"` Recheck bool `mapstructure:"recheck"` Broadcast bool `mapstructure:"broadcast"` - WalPath string `mapstructure:"wal_dir"` + WalPath string `mapstructure:"wal-dir"` // Maximum number of transactions in the mempool Size int `mapstructure:"size"` // Limit the total size of all txs in the mempool. // This only accounts for raw transactions (e.g. given 1MB transactions and - // max_txs_bytes=5MB, mempool will only accept 5 transactions). - MaxTxsBytes int64 `mapstructure:"max_txs_bytes"` + // max-txs-bytes=5MB, mempool will only accept 5 transactions). + MaxTxsBytes int64 `mapstructure:"max-txs-bytes"` // Size of the cache (used to filter transactions we saw earlier) in transactions - CacheSize int `mapstructure:"cache_size"` + CacheSize int `mapstructure:"cache-size"` // Maximum size of a single transaction - // NOTE: the max size of a tx transmitted over the network is {max_tx_bytes}. - MaxTxBytes int `mapstructure:"max_tx_bytes"` + // NOTE: the max size of a tx transmitted over the network is {max-tx-bytes}. + MaxTxBytes int `mapstructure:"max-tx-bytes"` // Maximum size of a batch of transactions to send to a peer // Including space needed by encoding (one varint per transaction). - MaxBatchBytes int `mapstructure:"max_batch_bytes"` + MaxBatchBytes int `mapstructure:"max-batch-bytes"` } // DefaultMempoolConfig returns a default configuration for the Tendermint mempool @@ -679,19 +679,19 @@ func (cfg *MempoolConfig) ValidateBasic() error { return errors.New("size can't be negative") } if cfg.MaxTxsBytes < 0 { - return errors.New("max_txs_bytes can't be negative") + return errors.New("max-txs-bytes can't be negative") } if cfg.CacheSize < 0 { - return errors.New("cache_size can't be negative") + return errors.New("cache-size can't be negative") } if cfg.MaxTxBytes < 0 { - return errors.New("max_tx_bytes can't be negative") + return errors.New("max-tx-bytes can't be negative") } if cfg.MaxBatchBytes < 0 { - return errors.New("max_batch_bytes can't be negative") + return errors.New("max-batch-bytes can't be negative") } if cfg.MaxBatchBytes <= cfg.MaxTxBytes { - return errors.New("max_batch_bytes can't be less or equal to max_tx_bytes") + return errors.New("max-batch-bytes can't be less or equal to max-tx-bytes") } return nil } @@ -702,12 +702,12 @@ func (cfg *MempoolConfig) ValidateBasic() error { // StateSyncConfig defines the configuration for the Tendermint state sync service type StateSyncConfig struct { Enable bool `mapstructure:"enable"` - TempDir string `mapstructure:"temp_dir"` - RPCServers []string `mapstructure:"rpc_servers"` - TrustPeriod time.Duration `mapstructure:"trust_period"` - TrustHeight int64 `mapstructure:"trust_height"` - TrustHash string `mapstructure:"trust_hash"` - DiscoveryTime time.Duration `mapstructure:"discovery_time"` + TempDir string `mapstructure:"temp-dir"` + RPCServers []string `mapstructure:"rpc-servers"` + TrustPeriod time.Duration `mapstructure:"trust-period"` + TrustHeight int64 `mapstructure:"trust-height"` + TrustHash string `mapstructure:"trust-hash"` + DiscoveryTime time.Duration `mapstructure:"discovery-time"` } func (cfg *StateSyncConfig) TrustHashBytes() []byte { @@ -736,28 +736,28 @@ func TestStateSyncConfig() *StateSyncConfig { func (cfg *StateSyncConfig) ValidateBasic() error { if cfg.Enable { if len(cfg.RPCServers) == 0 { - return errors.New("rpc_servers is required") + return errors.New("rpc-servers is required") } if len(cfg.RPCServers) < 2 { - return errors.New("at least two rpc_servers entries is required") + return errors.New("at least two rpc-servers entries is required") } for _, server := range cfg.RPCServers { if len(server) == 0 { - return errors.New("found empty rpc_servers entry") + return errors.New("found empty rpc-servers entry") } } if cfg.TrustPeriod <= 0 { - return errors.New("trusted_period is required") + return errors.New("trusted-period is required") } if cfg.TrustHeight <= 0 { - return errors.New("trusted_height is required") + return errors.New("trusted-height is required") } if len(cfg.TrustHash) == 0 { - return errors.New("trusted_hash is required") + return errors.New("trusted-hash is required") } _, err := hex.DecodeString(cfg.TrustHash) if err != nil { - return fmt.Errorf("invalid trusted_hash: %w", err) + return fmt.Errorf("invalid trusted-hash: %w", err) } } return nil @@ -802,39 +802,39 @@ func (cfg *FastSyncConfig) ValidateBasic() error { // including timeouts and details about the WAL and the block structure. type ConsensusConfig struct { RootDir string `mapstructure:"home"` - WalPath string `mapstructure:"wal_file"` + WalPath string `mapstructure:"wal-file"` walFile string // overrides WalPath if set // How long we wait for a proposal block before prevoting nil - TimeoutPropose time.Duration `mapstructure:"timeout_propose"` - // How much timeout_propose increases with each round - TimeoutProposeDelta time.Duration `mapstructure:"timeout_propose_delta"` + TimeoutPropose time.Duration `mapstructure:"timeout-propose"` + // How much timeout-propose increases with each round + TimeoutProposeDelta time.Duration `mapstructure:"timeout-propose-delta"` // How long we wait after receiving +2/3 prevotes for “anything” (ie. not a single block or nil) - TimeoutPrevote time.Duration `mapstructure:"timeout_prevote"` - // How much the timeout_prevote increases with each round - TimeoutPrevoteDelta time.Duration `mapstructure:"timeout_prevote_delta"` + TimeoutPrevote time.Duration `mapstructure:"timeout-prevote"` + // How much the timeout-prevote increases with each round + TimeoutPrevoteDelta time.Duration `mapstructure:"timeout-prevote-delta"` // How long we wait after receiving +2/3 precommits for “anything” (ie. not a single block or nil) - TimeoutPrecommit time.Duration `mapstructure:"timeout_precommit"` - // How much the timeout_precommit increases with each round - TimeoutPrecommitDelta time.Duration `mapstructure:"timeout_precommit_delta"` + TimeoutPrecommit time.Duration `mapstructure:"timeout-precommit"` + // How much the timeout-precommit increases with each round + TimeoutPrecommitDelta time.Duration `mapstructure:"timeout-precommit-delta"` // How long we wait after committing a block, before starting on the new // height (this gives us a chance to receive some more precommits, even // though we already have +2/3). - // NOTE: when modifying, make sure to update time_iota_ms genesis parameter - TimeoutCommit time.Duration `mapstructure:"timeout_commit"` + // NOTE: when modifying, make sure to update time-iota-ms genesis parameter + TimeoutCommit time.Duration `mapstructure:"timeout-commit"` // Make progress as soon as we have all the precommits (as if TimeoutCommit = 0) - SkipTimeoutCommit bool `mapstructure:"skip_timeout_commit"` + SkipTimeoutCommit bool `mapstructure:"skip-timeout-commit"` // EmptyBlocks mode and possible interval between empty blocks - CreateEmptyBlocks bool `mapstructure:"create_empty_blocks"` - CreateEmptyBlocksInterval time.Duration `mapstructure:"create_empty_blocks_interval"` + CreateEmptyBlocks bool `mapstructure:"create-empty-blocks"` + CreateEmptyBlocksInterval time.Duration `mapstructure:"create-empty-blocks-interval"` // Reactor sleep duration parameters - PeerGossipSleepDuration time.Duration `mapstructure:"peer_gossip_sleep_duration"` - PeerQueryMaj23SleepDuration time.Duration `mapstructure:"peer_query_maj23_sleep_duration"` + PeerGossipSleepDuration time.Duration `mapstructure:"peer-gossip-sleep-duration"` + PeerQueryMaj23SleepDuration time.Duration `mapstructure:"peer-query-maj23-sleep-duration"` - DoubleSignCheckHeight int64 `mapstructure:"double_sign_check_height"` + DoubleSignCheckHeight int64 `mapstructure:"double-sign-check-height"` } // DefaultConsensusConfig returns a default configuration for the consensus service @@ -924,37 +924,37 @@ func (cfg *ConsensusConfig) SetWalFile(walFile string) { // returns an error if any check fails. func (cfg *ConsensusConfig) ValidateBasic() error { if cfg.TimeoutPropose < 0 { - return errors.New("timeout_propose can't be negative") + return errors.New("timeout-propose can't be negative") } if cfg.TimeoutProposeDelta < 0 { - return errors.New("timeout_propose_delta can't be negative") + return errors.New("timeout-propose-delta can't be negative") } if cfg.TimeoutPrevote < 0 { - return errors.New("timeout_prevote can't be negative") + return errors.New("timeout-prevote can't be negative") } if cfg.TimeoutPrevoteDelta < 0 { - return errors.New("timeout_prevote_delta can't be negative") + return errors.New("timeout-prevote-delta can't be negative") } if cfg.TimeoutPrecommit < 0 { - return errors.New("timeout_precommit can't be negative") + return errors.New("timeout-precommit can't be negative") } if cfg.TimeoutPrecommitDelta < 0 { - return errors.New("timeout_precommit_delta can't be negative") + return errors.New("timeout-precommit-delta can't be negative") } if cfg.TimeoutCommit < 0 { - return errors.New("timeout_commit can't be negative") + return errors.New("timeout-commit can't be negative") } if cfg.CreateEmptyBlocksInterval < 0 { - return errors.New("create_empty_blocks_interval can't be negative") + return errors.New("create-empty-blocks-interval can't be negative") } if cfg.PeerGossipSleepDuration < 0 { - return errors.New("peer_gossip_sleep_duration can't be negative") + return errors.New("peer-gossip-sleep-duration can't be negative") } if cfg.PeerQueryMaj23SleepDuration < 0 { - return errors.New("peer_query_maj23_sleep_duration can't be negative") + return errors.New("peer-query-maj23-sleep-duration can't be negative") } if cfg.DoubleSignCheckHeight < 0 { - return errors.New("double_sign_check_height can't be negative") + return errors.New("double-sign-check-height can't be negative") } return nil } @@ -1003,13 +1003,13 @@ type InstrumentationConfig struct { Prometheus bool `mapstructure:"prometheus"` // Address to listen for Prometheus collector(s) connections. - PrometheusListenAddr string `mapstructure:"prometheus_listen_addr"` + PrometheusListenAddr string `mapstructure:"prometheus-listen-addr"` // Maximum number of simultaneous connections. // If you want to accept a larger number than the default, make sure // you increase your OS limits. // 0 - unlimited. - MaxOpenConnections int `mapstructure:"max_open_connections"` + MaxOpenConnections int `mapstructure:"max-open-connections"` // Instrumentation namespace. Namespace string `mapstructure:"namespace"` @@ -1036,7 +1036,7 @@ func TestInstrumentationConfig() *InstrumentationConfig { // returns an error if any check fails. func (cfg *InstrumentationConfig) ValidateBasic() error { if cfg.MaxOpenConnections < 0 { - return errors.New("max_open_connections can't be negative") + return errors.New("max-open-connections can't be negative") } return nil } diff --git a/config/toml.go b/config/toml.go index 99ed8d13d..a6d735922 100644 --- a/config/toml.go +++ b/config/toml.go @@ -83,7 +83,7 @@ const defaultConfigTemplate = `# This is a TOML config file. # TCP or UNIX socket address of the ABCI application, # or the name of an ABCI application compiled in with the Tendermint binary -proxy_app = "{{ .BaseConfig.ProxyApp }}" +proxy-app = "{{ .BaseConfig.ProxyApp }}" # A custom human readable name for this node moniker = "{{ .BaseConfig.Moniker }}" @@ -91,7 +91,7 @@ moniker = "{{ .BaseConfig.Moniker }}" # If this node is many blocks behind the tip of the chain, FastSync # allows them to catchup quickly by downloading blocks in parallel # and verifying their commits -fast_sync = {{ .BaseConfig.FastSyncMode }} +fast-sync = {{ .BaseConfig.FastSyncMode }} # Database backend: goleveldb | cleveldb | boltdb | rocksdb | badgerdb # * goleveldb (github.com/syndtr/goleveldb - most popular implementation) @@ -112,41 +112,41 @@ fast_sync = {{ .BaseConfig.FastSyncMode }} # * badgerdb (uses github.com/dgraph-io/badger) # - EXPERIMENTAL # - use badgerdb build tag (go build -tags badgerdb) -db_backend = "{{ .BaseConfig.DBBackend }}" +db-backend = "{{ .BaseConfig.DBBackend }}" # Database directory -db_dir = "{{ js .BaseConfig.DBPath }}" +db-dir = "{{ js .BaseConfig.DBPath }}" # Output level for logging, including package level options -log_level = "{{ .BaseConfig.LogLevel }}" +log-level = "{{ .BaseConfig.LogLevel }}" # Output format: 'plain' (colored text) or 'json' -log_format = "{{ .BaseConfig.LogFormat }}" +log-format = "{{ .BaseConfig.LogFormat }}" ##### additional base config options ##### # Path to the JSON file containing the initial validator set and other meta data -genesis_file = "{{ js .BaseConfig.Genesis }}" +genesis-file = "{{ js .BaseConfig.Genesis }}" # Path to the JSON file containing the private key to use as a validator in the consensus protocol -priv_validator_key_file = "{{ js .BaseConfig.PrivValidatorKey }}" +priv-validator-key-file = "{{ js .BaseConfig.PrivValidatorKey }}" # Path to the JSON file containing the last sign state of a validator -priv_validator_state_file = "{{ js .BaseConfig.PrivValidatorState }}" +priv-validator-state-file = "{{ js .BaseConfig.PrivValidatorState }}" # TCP or UNIX socket address for Tendermint to listen on for # connections from an external PrivValidator process -priv_validator_laddr = "{{ .BaseConfig.PrivValidatorListenAddr }}" +priv-validator-laddr = "{{ .BaseConfig.PrivValidatorListenAddr }}" # Path to the JSON file containing the private key to use for node authentication in the p2p protocol -node_key_file = "{{ js .BaseConfig.NodeKey }}" +node-key-file = "{{ js .BaseConfig.NodeKey }}" # Mechanism to connect to the ABCI application: socket | grpc abci = "{{ .BaseConfig.ABCI }}" # If true, query the ABCI app on connecting to a new peer # so the app can decide if we should keep the connection or not -filter_peers = {{ .BaseConfig.FilterPeers }} +filter-peers = {{ .BaseConfig.FilterPeers }} ####################################################################### @@ -164,78 +164,78 @@ laddr = "{{ .RPC.ListenAddress }}" # A list of origins a cross-domain request can be executed from # Default value '[]' disables cors support # Use '["*"]' to allow any origin -cors_allowed_origins = [{{ range .RPC.CORSAllowedOrigins }}{{ printf "%q, " . }}{{end}}] +cors-allowed-origins = [{{ range .RPC.CORSAllowedOrigins }}{{ printf "%q, " . }}{{end}}] # A list of methods the client is allowed to use with cross-domain requests -cors_allowed_methods = [{{ range .RPC.CORSAllowedMethods }}{{ printf "%q, " . }}{{end}}] +cors-allowed-methods = [{{ range .RPC.CORSAllowedMethods }}{{ printf "%q, " . }}{{end}}] # A list of non simple headers the client is allowed to use with cross-domain requests -cors_allowed_headers = [{{ range .RPC.CORSAllowedHeaders }}{{ printf "%q, " . }}{{end}}] +cors-allowed-headers = [{{ range .RPC.CORSAllowedHeaders }}{{ printf "%q, " . }}{{end}}] # TCP or UNIX socket address for the gRPC server to listen on # NOTE: This server only supports /broadcast_tx_commit -grpc_laddr = "{{ .RPC.GRPCListenAddress }}" +grpc-laddr = "{{ .RPC.GRPCListenAddress }}" # Maximum number of simultaneous connections. -# Does not include RPC (HTTP&WebSocket) connections. See max_open_connections +# Does not include RPC (HTTP&WebSocket) connections. See max-open-connections # If you want to accept a larger number than the default, make sure # you increase your OS limits. # 0 - unlimited. # Should be < {ulimit -Sn} - {MaxNumInboundPeers} - {MaxNumOutboundPeers} - {N of wal, db and other open files} # 1024 - 40 - 10 - 50 = 924 = ~900 -grpc_max_open_connections = {{ .RPC.GRPCMaxOpenConnections }} +grpc-max-open-connections = {{ .RPC.GRPCMaxOpenConnections }} -# Activate unsafe RPC commands like /dial_seeds and /unsafe_flush_mempool +# Activate unsafe RPC commands like /dial-seeds and /unsafe-flush-mempool unsafe = {{ .RPC.Unsafe }} # Maximum number of simultaneous connections (including WebSocket). -# Does not include gRPC connections. See grpc_max_open_connections +# Does not include gRPC connections. See grpc-max-open-connections # If you want to accept a larger number than the default, make sure # you increase your OS limits. # 0 - unlimited. # Should be < {ulimit -Sn} - {MaxNumInboundPeers} - {MaxNumOutboundPeers} - {N of wal, db and other open files} # 1024 - 40 - 10 - 50 = 924 = ~900 -max_open_connections = {{ .RPC.MaxOpenConnections }} +max-open-connections = {{ .RPC.MaxOpenConnections }} # Maximum number of unique clientIDs that can /subscribe # If you're using /broadcast_tx_commit, set to the estimated maximum number # of broadcast_tx_commit calls per block. -max_subscription_clients = {{ .RPC.MaxSubscriptionClients }} +max-subscription-clients = {{ .RPC.MaxSubscriptionClients }} # Maximum number of unique queries a given client can /subscribe to # If you're using GRPC (or Local RPC client) and /broadcast_tx_commit, set to # the estimated # maximum number of broadcast_tx_commit calls per block. -max_subscriptions_per_client = {{ .RPC.MaxSubscriptionsPerClient }} +max-subscriptions-per-client = {{ .RPC.MaxSubscriptionsPerClient }} # How long to wait for a tx to be committed during /broadcast_tx_commit. # WARNING: Using a value larger than 10s will result in increasing the # global HTTP write timeout, which applies to all connections and endpoints. # See https://github.com/tendermint/tendermint/issues/3435 -timeout_broadcast_tx_commit = "{{ .RPC.TimeoutBroadcastTxCommit }}" +timeout-broadcast-tx-commit = "{{ .RPC.TimeoutBroadcastTxCommit }}" # Maximum size of request body, in bytes -max_body_bytes = {{ .RPC.MaxBodyBytes }} +max-body-bytes = {{ .RPC.MaxBodyBytes }} # Maximum size of request header, in bytes -max_header_bytes = {{ .RPC.MaxHeaderBytes }} +max-header-bytes = {{ .RPC.MaxHeaderBytes }} # The path to a file containing certificate that is used to create the HTTPS server. # Migth be either absolute path or path related to tendermint's config directory. # If the certificate is signed by a certificate authority, # the certFile should be the concatenation of the server's certificate, any intermediates, # and the CA's certificate. -# NOTE: both tls_cert_file and tls_key_file must be present for Tendermint to create HTTPS server. +# NOTE: both tls-cert-file and tls-key-file must be present for Tendermint to create HTTPS server. # Otherwise, HTTP server is run. -tls_cert_file = "{{ .RPC.TLSCertFile }}" +tls-cert-file = "{{ .RPC.TLSCertFile }}" # The path to a file containing matching private key that is used to create the HTTPS server. # Migth be either absolute path or path related to tendermint's config directory. -# NOTE: both tls_cert_file and tls_key_file must be present for Tendermint to create HTTPS server. +# NOTE: both tls-cert-file and tls-key-file must be present for Tendermint to create HTTPS server. # Otherwise, HTTP server is run. -tls_key_file = "{{ .RPC.TLSKeyFile }}" +tls-key-file = "{{ .RPC.TLSKeyFile }}" # pprof listen address (https://golang.org/pkg/net/http/pprof) -pprof_laddr = "{{ .RPC.PprofListenAddress }}" +pprof-laddr = "{{ .RPC.PprofListenAddress }}" ####################################################### ### P2P Configuration Options ### @@ -249,47 +249,47 @@ laddr = "{{ .P2P.ListenAddress }}" # If empty, will use the same port as the laddr, # and will introspect on the listener or use UPnP # to figure out the address. -external_address = "{{ .P2P.ExternalAddress }}" +external-address = "{{ .P2P.ExternalAddress }}" # Comma separated list of seed nodes to connect to seeds = "{{ .P2P.Seeds }}" # Comma separated list of nodes to keep persistent connections to -persistent_peers = "{{ .P2P.PersistentPeers }}" +persistent-peers = "{{ .P2P.PersistentPeers }}" # UPNP port forwarding upnp = {{ .P2P.UPNP }} # Path to address book -addr_book_file = "{{ js .P2P.AddrBook }}" +addr-book-file = "{{ js .P2P.AddrBook }}" # Set true for strict address routability rules # Set false for private or local networks -addr_book_strict = {{ .P2P.AddrBookStrict }} +addr-book-strict = {{ .P2P.AddrBookStrict }} # Maximum number of inbound peers -max_num_inbound_peers = {{ .P2P.MaxNumInboundPeers }} +max-num-inbound-peers = {{ .P2P.MaxNumInboundPeers }} # Maximum number of outbound peers to connect to, excluding persistent peers -max_num_outbound_peers = {{ .P2P.MaxNumOutboundPeers }} +max-num-outbound-peers = {{ .P2P.MaxNumOutboundPeers }} # List of node IDs, to which a connection will be (re)established ignoring any existing limits -unconditional_peer_ids = "{{ .P2P.UnconditionalPeerIDs }}" +unconditional-peer-ids = "{{ .P2P.UnconditionalPeerIDs }}" # Maximum pause when redialing a persistent peer (if zero, exponential backoff is used) -persistent_peers_max_dial_period = "{{ .P2P.PersistentPeersMaxDialPeriod }}" +persistent-peers-max-dial-period = "{{ .P2P.PersistentPeersMaxDialPeriod }}" # Time to wait before flushing messages out on the connection -flush_throttle_timeout = "{{ .P2P.FlushThrottleTimeout }}" +flush-throttle-timeout = "{{ .P2P.FlushThrottleTimeout }}" # Maximum size of a message packet payload, in bytes -max_packet_msg_payload_size = {{ .P2P.MaxPacketMsgPayloadSize }} +max-packet-msg-payload-size = {{ .P2P.MaxPacketMsgPayloadSize }} # Rate at which packets can be sent, in bytes/second -send_rate = {{ .P2P.SendRate }} +send-rate = {{ .P2P.SendRate }} # Rate at which packets can be received, in bytes/second -recv_rate = {{ .P2P.RecvRate }} +recv-rate = {{ .P2P.RecvRate }} # Set true to enable the peer-exchange reactor pex = {{ .P2P.PexReactor }} @@ -298,17 +298,17 @@ pex = {{ .P2P.PexReactor }} # peers. If another node asks it for addresses, it responds and disconnects. # # Does not work if the peer-exchange reactor is disabled. -seed_mode = {{ .P2P.SeedMode }} +seed-mode = {{ .P2P.SeedMode }} # Comma separated list of peer IDs to keep private (will not be gossiped to other peers) -private_peer_ids = "{{ .P2P.PrivatePeerIDs }}" +private-peer-ids = "{{ .P2P.PrivatePeerIDs }}" # Toggle to disable guard against peers connecting from the same ip. -allow_duplicate_ip = {{ .P2P.AllowDuplicateIP }} +allow-duplicate-ip = {{ .P2P.AllowDuplicateIP }} # Peer connection configuration. -handshake_timeout = "{{ .P2P.HandshakeTimeout }}" -dial_timeout = "{{ .P2P.DialTimeout }}" +handshake-timeout = "{{ .P2P.HandshakeTimeout }}" +dial-timeout = "{{ .P2P.DialTimeout }}" ####################################################### ### Mempool Configurattion Option ### @@ -317,26 +317,26 @@ dial_timeout = "{{ .P2P.DialTimeout }}" recheck = {{ .Mempool.Recheck }} broadcast = {{ .Mempool.Broadcast }} -wal_dir = "{{ js .Mempool.WalPath }}" +wal-dir = "{{ js .Mempool.WalPath }}" # Maximum number of transactions in the mempool size = {{ .Mempool.Size }} # Limit the total size of all txs in the mempool. # This only accounts for raw transactions (e.g. given 1MB transactions and -# max_txs_bytes=5MB, mempool will only accept 5 transactions). -max_txs_bytes = {{ .Mempool.MaxTxsBytes }} +# max-txs-bytes=5MB, mempool will only accept 5 transactions). +max-txs-bytes = {{ .Mempool.MaxTxsBytes }} # Size of the cache (used to filter transactions we saw earlier) in transactions -cache_size = {{ .Mempool.CacheSize }} +cache-size = {{ .Mempool.CacheSize }} # Maximum size of a single transaction. -# NOTE: the max size of a tx transmitted over the network is {max_tx_bytes}. -max_tx_bytes = {{ .Mempool.MaxTxBytes }} +# NOTE: the max size of a tx transmitted over the network is {max-tx-bytes}. +max-tx-bytes = {{ .Mempool.MaxTxBytes }} # Maximum size of a batch of transactions to send to a peer # Including space needed by encoding (one varint per transaction). -max_batch_bytes = {{ .Mempool.MaxBatchBytes }} +max-batch-bytes = {{ .Mempool.MaxBatchBytes }} ####################################################### ### State Sync Configuration Options ### @@ -353,19 +353,19 @@ enable = {{ .StateSync.Enable }} # retrieval of state data for node bootstrapping. Also needs a trusted height and corresponding # header hash obtained from a trusted source, and a period during which validators can be trusted. # -# For Cosmos SDK-based chains, trust_period should usually be about 2/3 of the unbonding time (~2 +# For Cosmos SDK-based chains, trust-period should usually be about 2/3 of the unbonding time (~2 # weeks) during which they can be financially punished (slashed) for misbehavior. -rpc_servers = "{{ StringsJoin .StateSync.RPCServers "," }}" -trust_height = {{ .StateSync.TrustHeight }} -trust_hash = "{{ .StateSync.TrustHash }}" -trust_period = "{{ .StateSync.TrustPeriod }}" +rpc-servers = "{{ StringsJoin .StateSync.RPCServers "," }}" +trust-height = {{ .StateSync.TrustHeight }} +trust-hash = "{{ .StateSync.TrustHash }}" +trust-period = "{{ .StateSync.TrustPeriod }}" # Time to spend discovering snapshots before initiating a restore. -discovery_time = "{{ .StateSync.DiscoveryTime }}" +discovery-time = "{{ .StateSync.DiscoveryTime }}" # Temporary directory for state sync snapshot chunks, defaults to the OS tempdir (typically /tmp). # Will create a new, randomly named directory within, and remove it when done. -temp_dir = "{{ .StateSync.TempDir }}" +temp-dir = "{{ .StateSync.TempDir }}" ####################################################### ### Fast Sync Configuration Connections ### @@ -382,46 +382,46 @@ version = "{{ .FastSync.Version }}" ####################################################### [consensus] -wal_file = "{{ js .Consensus.WalPath }}" +wal-file = "{{ js .Consensus.WalPath }}" # How long we wait for a proposal block before prevoting nil -timeout_propose = "{{ .Consensus.TimeoutPropose }}" -# How much timeout_propose increases with each round -timeout_propose_delta = "{{ .Consensus.TimeoutProposeDelta }}" +timeout-propose = "{{ .Consensus.TimeoutPropose }}" +# How much timeout-propose increases with each round +timeout-propose-delta = "{{ .Consensus.TimeoutProposeDelta }}" # How long we wait after receiving +2/3 prevotes for “anything” (ie. not a single block or nil) -timeout_prevote = "{{ .Consensus.TimeoutPrevote }}" -# How much the timeout_prevote increases with each round -timeout_prevote_delta = "{{ .Consensus.TimeoutPrevoteDelta }}" +timeout-prevote = "{{ .Consensus.TimeoutPrevote }}" +# How much the timeout-prevote increases with each round +timeout-prevote-delta = "{{ .Consensus.TimeoutPrevoteDelta }}" # How long we wait after receiving +2/3 precommits for “anything” (ie. not a single block or nil) -timeout_precommit = "{{ .Consensus.TimeoutPrecommit }}" -# How much the timeout_precommit increases with each round -timeout_precommit_delta = "{{ .Consensus.TimeoutPrecommitDelta }}" +timeout-precommit = "{{ .Consensus.TimeoutPrecommit }}" +# How much the timeout-precommit increases with each round +timeout-precommit-delta = "{{ .Consensus.TimeoutPrecommitDelta }}" # How long we wait after committing a block, before starting on the new # height (this gives us a chance to receive some more precommits, even # though we already have +2/3). -timeout_commit = "{{ .Consensus.TimeoutCommit }}" +timeout-commit = "{{ .Consensus.TimeoutCommit }}" # How many blocks to look back to check existence of the node's consensus votes before joining consensus # When non-zero, the node will panic upon restart -# if the same consensus key was used to sign {double_sign_check_height} last blocks. +# if the same consensus key was used to sign {double-sign-check-height} last blocks. # So, validators should stop the state machine, wait for some blocks, and then restart the state machine to avoid panic. -double_sign_check_height = {{ .Consensus.DoubleSignCheckHeight }} +double-sign-check-height = {{ .Consensus.DoubleSignCheckHeight }} # Make progress as soon as we have all the precommits (as if TimeoutCommit = 0) -skip_timeout_commit = {{ .Consensus.SkipTimeoutCommit }} +skip-timeout-commit = {{ .Consensus.SkipTimeoutCommit }} # EmptyBlocks mode and possible interval between empty blocks -create_empty_blocks = {{ .Consensus.CreateEmptyBlocks }} -create_empty_blocks_interval = "{{ .Consensus.CreateEmptyBlocksInterval }}" +create-empty-blocks = {{ .Consensus.CreateEmptyBlocks }} +create-empty-blocks-interval = "{{ .Consensus.CreateEmptyBlocksInterval }}" # Reactor sleep duration parameters -peer_gossip_sleep_duration = "{{ .Consensus.PeerGossipSleepDuration }}" -peer_query_maj23_sleep_duration = "{{ .Consensus.PeerQueryMaj23SleepDuration }}" +peer-gossip-sleep-duration = "{{ .Consensus.PeerGossipSleepDuration }}" +peer-query-maj23-sleep-duration = "{{ .Consensus.PeerQueryMaj23SleepDuration }}" ####################################################### ### Transaction Indexer Configuration Options ### ####################################################### -[tx_index] +[tx-index] # What indexer to use for transactions # @@ -445,13 +445,13 @@ indexer = "{{ .TxIndex.Indexer }}" prometheus = {{ .Instrumentation.Prometheus }} # Address to listen for Prometheus collector(s) connections -prometheus_listen_addr = "{{ .Instrumentation.PrometheusListenAddr }}" +prometheus-listen-addr = "{{ .Instrumentation.PrometheusListenAddr }}" # Maximum number of simultaneous connections. # If you want to accept a larger number than the default, make sure # you increase your OS limits. # 0 - unlimited. -max_open_connections = {{ .Instrumentation.MaxOpenConnections }} +max-open-connections = {{ .Instrumentation.MaxOpenConnections }} # Instrumentation namespace namespace = "{{ .Instrumentation.Namespace }}" diff --git a/test/app/test.sh b/test/app/test.sh index dc60bfc1f..710aae80b 100755 --- a/test/app/test.sh +++ b/test/app/test.sh @@ -17,7 +17,7 @@ function kvstore_over_socket(){ echo "Starting kvstore_over_socket" abci-cli kvstore > /dev/null & pid_kvstore=$! - tendermint node > tendermint.log & + tendermint start > tendermint.log & pid_tendermint=$! sleep 5 @@ -32,7 +32,7 @@ function kvstore_over_socket_reorder(){ rm -rf $TMHOME tendermint init echo "Starting kvstore_over_socket_reorder (ie. start tendermint first)" - tendermint node > tendermint.log & + tendermint start > tendermint.log & pid_tendermint=$! sleep 2 abci-cli kvstore > /dev/null & @@ -52,7 +52,7 @@ function counter_over_socket() { echo "Starting counter_over_socket" abci-cli counter --serial > /dev/null & pid_counter=$! - tendermint node > tendermint.log & + tendermint start > tendermint.log & pid_tendermint=$! sleep 5 @@ -68,7 +68,7 @@ function counter_over_grpc() { echo "Starting counter_over_grpc" abci-cli counter --serial --abci grpc > /dev/null & pid_counter=$! - tendermint node --abci grpc > tendermint.log & + tendermint start --abci grpc > tendermint.log & pid_tendermint=$! sleep 5 @@ -86,7 +86,7 @@ function counter_over_grpc_grpc() { pid_counter=$! sleep 1 GRPC_PORT=36656 - tendermint node --abci grpc --rpc.grpc_laddr tcp://localhost:$GRPC_PORT > tendermint.log & + tendermint start --abci grpc --rpc.grpc-laddr tcp://localhost:$GRPC_PORT > tendermint.log & pid_tendermint=$! sleep 5 diff --git a/test/e2e/docker/Dockerfile b/test/e2e/docker/Dockerfile index 825aa7f0d..668c7f83e 100644 --- a/test/e2e/docker/Dockerfile +++ b/test/e2e/docker/Dockerfile @@ -29,5 +29,5 @@ ENV TMHOME=/tendermint EXPOSE 26656 26657 26660 ENTRYPOINT ["/usr/bin/entrypoint"] -CMD ["node"] +CMD ["start"] STOPSIGNAL SIGTERM diff --git a/test/e2e/runner/setup.go b/test/e2e/runner/setup.go index d9c3ab0cf..c0dd893d7 100644 --- a/test/e2e/runner/setup.go +++ b/test/e2e/runner/setup.go @@ -159,7 +159,7 @@ services: entrypoint: /usr/bin/entrypoint-builtin {{- else if .Misbehaviors }} entrypoint: /usr/bin/entrypoint-maverick - command: ["node", "--misbehaviors", "{{ misbehaviorsToString .Misbehaviors }}"] + command: ["start", "--misbehaviors", "{{ misbehaviorsToString .Misbehaviors }}"] {{- end }} init: true ports: @@ -392,7 +392,7 @@ func UpdateConfigStateSync(node *e2e.Node, height int64, hash []byte) error { if err != nil { return err } - bz = regexp.MustCompile(`(?m)^trust_height =.*`).ReplaceAll(bz, []byte(fmt.Sprintf(`trust_height = %v`, height))) - bz = regexp.MustCompile(`(?m)^trust_hash =.*`).ReplaceAll(bz, []byte(fmt.Sprintf(`trust_hash = "%X"`, hash))) + bz = regexp.MustCompile(`(?m)^trust-height =.*`).ReplaceAll(bz, []byte(fmt.Sprintf(`trust-height = %v`, height))) + bz = regexp.MustCompile(`(?m)^trust-hash =.*`).ReplaceAll(bz, []byte(fmt.Sprintf(`trust-hash = "%X"`, hash))) return ioutil.WriteFile(cfgPath, bz, 0644) } diff --git a/test/maverick/main.go b/test/maverick/main.go index d7a209e38..5a6dcfaf4 100644 --- a/test/maverick/main.go +++ b/test/maverick/main.go @@ -100,8 +100,9 @@ func main() { ) nodeCmd := &cobra.Command{ - Use: "node", - Short: "Run the maverick node", + Use: "start", + Aliases: []string{"node", "run"}, + Short: "Run the maverick node", RunE: func(command *cobra.Command, args []string) error { return startNode(config, logger, misbehaviorFlag) },