package config import ( "fmt" "os" "path/filepath" "time" "github.com/pkg/errors" ) const ( // FuzzModeDrop is a mode in which we randomly drop reads/writes, connections or sleep FuzzModeDrop = iota // FuzzModeDelay is a mode in which we randomly sleep FuzzModeDelay // LogFormatPlain is a format for colored text LogFormatPlain = "plain" // LogFormatJSON is a format for json output LogFormatJSON = "json" ) // NOTE: Most of the structs & relevant comments + the // default configuration options were used to manually // generate the config.toml. Please reflect any changes // made here in the defaultConfigTemplate constant in // config/toml.go // NOTE: libs/cli must know to look in the config dir! var ( DefaultTendermintDir = ".tendermint" defaultConfigDir = "config" defaultDataDir = "data" defaultConfigFileName = "config.toml" defaultGenesisJSONName = "genesis.json" defaultPrivValKeyName = "priv_validator_key.json" defaultPrivValStateName = "priv_validator_state.json" defaultNodeKeyName = "node_key.json" defaultAddrBookName = "addrbook.json" defaultConfigFilePath = filepath.Join(defaultConfigDir, defaultConfigFileName) defaultGenesisJSONPath = filepath.Join(defaultConfigDir, defaultGenesisJSONName) defaultPrivValKeyPath = filepath.Join(defaultConfigDir, defaultPrivValKeyName) defaultPrivValStatePath = filepath.Join(defaultDataDir, defaultPrivValStateName) defaultNodeKeyPath = filepath.Join(defaultConfigDir, defaultNodeKeyName) defaultAddrBookPath = filepath.Join(defaultConfigDir, defaultAddrBookName) ) var ( oldPrivVal = "priv_validator.json" oldPrivValPath = filepath.Join(defaultConfigDir, oldPrivVal) ) // Config defines the top level configuration for a Tendermint node type Config struct { // Top level options use an anonymous struct BaseConfig `mapstructure:",squash"` // Options for services RPC *RPCConfig `mapstructure:"rpc"` P2P *P2PConfig `mapstructure:"p2p"` Mempool *MempoolConfig `mapstructure:"mempool"` Consensus *ConsensusConfig `mapstructure:"consensus"` TxIndex *TxIndexConfig `mapstructure:"tx_index"` Instrumentation *InstrumentationConfig `mapstructure:"instrumentation"` } // DefaultConfig returns a default configuration for a Tendermint node func DefaultConfig() *Config { return &Config{ BaseConfig: DefaultBaseConfig(), RPC: DefaultRPCConfig(), P2P: DefaultP2PConfig(), Mempool: DefaultMempoolConfig(), Consensus: DefaultConsensusConfig(), TxIndex: DefaultTxIndexConfig(), Instrumentation: DefaultInstrumentationConfig(), } } // TestConfig returns a configuration that can be used for testing func TestConfig() *Config { return &Config{ BaseConfig: TestBaseConfig(), RPC: TestRPCConfig(), P2P: TestP2PConfig(), Mempool: TestMempoolConfig(), Consensus: TestConsensusConfig(), TxIndex: TestTxIndexConfig(), Instrumentation: TestInstrumentationConfig(), } } // SetRoot sets the RootDir for all Config structs func (cfg *Config) SetRoot(root string) *Config { cfg.BaseConfig.RootDir = root cfg.RPC.RootDir = root cfg.P2P.RootDir = root cfg.Mempool.RootDir = root cfg.Consensus.RootDir = root return cfg } // ValidateBasic performs basic validation (checking param bounds, etc.) and // returns an error if any check fails. func (cfg *Config) ValidateBasic() error { if err := cfg.BaseConfig.ValidateBasic(); err != nil { return err } if err := cfg.RPC.ValidateBasic(); err != nil { return errors.Wrap(err, "Error in [rpc] section") } if err := cfg.P2P.ValidateBasic(); err != nil { return errors.Wrap(err, "Error in [p2p] section") } if err := cfg.Mempool.ValidateBasic(); err != nil { return errors.Wrap(err, "Error in [mempool] section") } if err := cfg.Consensus.ValidateBasic(); err != nil { return errors.Wrap(err, "Error in [consensus] section") } return errors.Wrap( cfg.Instrumentation.ValidateBasic(), "Error in [instrumentation] section", ) } //----------------------------------------------------------------------------- // BaseConfig // BaseConfig defines the base configuration for a Tendermint node type BaseConfig struct { // chainID is unexposed and immutable but here for convenience chainID string // The root directory for all data. // This should be set in viper so it can unmarshal into this struct RootDir string `mapstructure:"home"` // 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"` // A custom human readable name for this node Moniker string `mapstructure:"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 FastSync bool `mapstructure:"fast_sync"` // Database backend: goleveldb | cleveldb | boltdb // * goleveldb (github.com/syndtr/goleveldb - most popular implementation) // - pure go // - stable // * cleveldb (uses levigo wrapper) // - fast // - requires gcc // - use cleveldb build tag (go build -tags cleveldb) // * boltdb (uses etcd's fork of bolt - github.com/etcd-io/bbolt) // - EXPERIMENTAL // - may be faster is some use-cases (random reads - indexer) // - use boltdb build tag (go build -tags boltdb) DBBackend string `mapstructure:"db_backend"` // Database directory DBPath string `mapstructure:"db_dir"` // Output level for logging LogLevel string `mapstructure:"log_level"` // Output format: 'plain' (colored text) or 'json' LogFormat string `mapstructure:"log_format"` // Path to the JSON file containing the initial validator set and other meta data 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"` // Path to the JSON file containing the last sign state of a validator 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"` // A JSON file containing the private key to use for p2p authenticated encryption NodeKey string `mapstructure:"node_key_file"` // Mechanism to connect to the ABCI application: socket | grpc ABCI string `mapstructure:"abci"` // TCP or UNIX socket address for the profiling server to listen on ProfListenAddress string `mapstructure:"prof_laddr"` // 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 } // DefaultBaseConfig returns a default base configuration for a Tendermint node func DefaultBaseConfig() BaseConfig { return BaseConfig{ Genesis: defaultGenesisJSONPath, PrivValidatorKey: defaultPrivValKeyPath, PrivValidatorState: defaultPrivValStatePath, NodeKey: defaultNodeKeyPath, Moniker: defaultMoniker, ProxyApp: "tcp://127.0.0.1:26658", ABCI: "socket", LogLevel: DefaultPackageLogLevels(), LogFormat: LogFormatPlain, ProfListenAddress: "", FastSync: true, FilterPeers: false, DBBackend: "goleveldb", DBPath: "data", } } // TestBaseConfig returns a base configuration for testing a Tendermint node func TestBaseConfig() BaseConfig { cfg := DefaultBaseConfig() cfg.chainID = "tendermint_test" cfg.ProxyApp = "kvstore" cfg.FastSync = false cfg.DBBackend = "memdb" return cfg } func (cfg BaseConfig) ChainID() string { return cfg.chainID } // GenesisFile returns the full path to the genesis.json file func (cfg BaseConfig) GenesisFile() string { return rootify(cfg.Genesis, cfg.RootDir) } // PrivValidatorKeyFile returns the full path to the priv_validator_key.json file func (cfg BaseConfig) PrivValidatorKeyFile() string { return rootify(cfg.PrivValidatorKey, cfg.RootDir) } // PrivValidatorFile returns the full path to the priv_validator_state.json file func (cfg BaseConfig) PrivValidatorStateFile() string { return rootify(cfg.PrivValidatorState, cfg.RootDir) } // OldPrivValidatorFile returns the full path of the priv_validator.json from pre v0.28.0. // TODO: eventually remove. func (cfg BaseConfig) OldPrivValidatorFile() string { return rootify(oldPrivValPath, cfg.RootDir) } // NodeKeyFile returns the full path to the node_key.json file func (cfg BaseConfig) NodeKeyFile() string { return rootify(cfg.NodeKey, cfg.RootDir) } // DBDir returns the full path to the database directory func (cfg BaseConfig) DBDir() string { return rootify(cfg.DBPath, cfg.RootDir) } // ValidateBasic performs basic validation (checking param bounds, etc.) and // returns an error if any check fails. func (cfg BaseConfig) ValidateBasic() error { switch cfg.LogFormat { case LogFormatPlain, LogFormatJSON: default: return errors.New("unknown log_format (must be 'plain' or 'json')") } return nil } // DefaultLogLevel returns a default log level of "error" func DefaultLogLevel() string { return "error" } // DefaultPackageLogLevels returns a default log level setting so all packages // log at "error", while the `state` and `main` packages log at "info" func DefaultPackageLogLevels() string { return fmt.Sprintf("main:info,state:info,*:%s", DefaultLogLevel()) } //----------------------------------------------------------------------------- // RPCConfig // RPCConfig defines the configuration options for the Tendermint RPC server type RPCConfig struct { RootDir string `mapstructure:"home"` // TCP or UNIX socket address for the RPC server to listen on ListenAddress string `mapstructure:"laddr"` // A list of origins a cross-domain request can be executed from. // 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"` // A list of methods the client is allowed to use with cross-domain requests. 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"` // 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"` // Maximum number of simultaneous 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"` // 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 // 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"` // 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"` // 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"` // 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"` // The name of a file containing certificate that is used to create the HTTPS server. // // 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. Otherwise, HTTP server is run. TLSCertFile string `mapstructure:"tls_cert_file"` // The name of a file containing matching private key that is used to create the 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"` } // DefaultRPCConfig returns a default configuration for the RPC server func DefaultRPCConfig() *RPCConfig { return &RPCConfig{ ListenAddress: "tcp://0.0.0.0:26657", CORSAllowedOrigins: []string{}, CORSAllowedMethods: []string{"HEAD", "GET", "POST"}, CORSAllowedHeaders: []string{"Origin", "Accept", "Content-Type", "X-Requested-With", "X-Server-Time"}, GRPCListenAddress: "", GRPCMaxOpenConnections: 900, Unsafe: false, MaxOpenConnections: 900, MaxSubscriptionClients: 100, MaxSubscriptionsPerClient: 5, TimeoutBroadcastTxCommit: 10 * time.Second, TLSCertFile: "", TLSKeyFile: "", } } // TestRPCConfig returns a configuration for testing the RPC server func TestRPCConfig() *RPCConfig { cfg := DefaultRPCConfig() cfg.ListenAddress = "tcp://0.0.0.0:36657" cfg.GRPCListenAddress = "tcp://0.0.0.0:36658" cfg.Unsafe = true return cfg } // ValidateBasic performs basic validation (checking param bounds, etc.) and // 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") } if cfg.MaxOpenConnections < 0 { return errors.New("max_open_connections can't be negative") } if cfg.MaxSubscriptionClients < 0 { 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") } if cfg.TimeoutBroadcastTxCommit < 0 { return errors.New("timeout_broadcast_tx_commit can't be negative") } return nil } // IsCorsEnabled returns true if cross-origin resource sharing is enabled. func (cfg *RPCConfig) IsCorsEnabled() bool { return len(cfg.CORSAllowedOrigins) != 0 } func (cfg RPCConfig) KeyFile() string { return rootify(filepath.Join(defaultConfigDir, cfg.TLSKeyFile), cfg.RootDir) } func (cfg RPCConfig) CertFile() string { return rootify(filepath.Join(defaultConfigDir, cfg.TLSCertFile), cfg.RootDir) } func (cfg RPCConfig) IsTLSEnabled() bool { return cfg.TLSCertFile != "" && cfg.TLSKeyFile != "" } //----------------------------------------------------------------------------- // P2PConfig // P2PConfig defines the configuration options for the Tendermint peer-to-peer networking layer type P2PConfig struct { RootDir string `mapstructure:"home"` // Address to listen for incoming connections ListenAddress string `mapstructure:"laddr"` // Address to advertise to peers for them to dial 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"` // UPNP port forwarding UPNP bool `mapstructure:"upnp"` // Path to address book 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"` // Maximum number of 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"` // Time to wait before flushing messages out on the connection FlushThrottleTimeout time.Duration `mapstructure:"flush_throttle_timeout"` // Maximum size of a message packet payload, in bytes MaxPacketMsgPayloadSize int `mapstructure:"max_packet_msg_payload_size"` // Rate at which packets can be sent, in bytes/second SendRate int64 `mapstructure:"send_rate"` // Rate at which packets can be received, in bytes/second RecvRate int64 `mapstructure:"recv_rate"` // Set true to enable the peer-exchange reactor PexReactor bool `mapstructure:"pex"` // Seed mode, in which node constantly crawls the network and looks for // 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"` // Comma separated list of peer IDs to keep private (will not be gossiped to // other peers) PrivatePeerIDs string `mapstructure:"private_peer_ids"` // Toggle to disable guard against peers connecting from the same ip. AllowDuplicateIP bool `mapstructure:"allow_duplicate_ip"` // Peer connection configuration. HandshakeTimeout time.Duration `mapstructure:"handshake_timeout"` DialTimeout time.Duration `mapstructure:"dial_timeout"` // Testing params. // Force dial to fail TestDialFail bool `mapstructure:"test_dial_fail"` // FUzz connection TestFuzz bool `mapstructure:"test_fuzz"` TestFuzzConfig *FuzzConnConfig `mapstructure:"test_fuzz_config"` } // DefaultP2PConfig returns a default configuration for the peer-to-peer layer func DefaultP2PConfig() *P2PConfig { return &P2PConfig{ ListenAddress: "tcp://0.0.0.0:26656", ExternalAddress: "", UPNP: false, AddrBook: defaultAddrBookPath, AddrBookStrict: true, MaxNumInboundPeers: 40, MaxNumOutboundPeers: 10, FlushThrottleTimeout: 100 * time.Millisecond, MaxPacketMsgPayloadSize: 1024, // 1 kB SendRate: 5120000, // 5 mB/s RecvRate: 5120000, // 5 mB/s PexReactor: true, SeedMode: false, AllowDuplicateIP: false, HandshakeTimeout: 20 * time.Second, DialTimeout: 3 * time.Second, TestDialFail: false, TestFuzz: false, TestFuzzConfig: DefaultFuzzConnConfig(), } } // TestP2PConfig returns a configuration for testing the peer-to-peer layer func TestP2PConfig() *P2PConfig { cfg := DefaultP2PConfig() cfg.ListenAddress = "tcp://0.0.0.0:36656" cfg.FlushThrottleTimeout = 10 * time.Millisecond cfg.AllowDuplicateIP = true return cfg } // AddrBookFile returns the full path to the address book func (cfg *P2PConfig) AddrBookFile() string { return rootify(cfg.AddrBook, cfg.RootDir) } // ValidateBasic performs basic validation (checking param bounds, etc.) and // 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") } if cfg.MaxNumOutboundPeers < 0 { 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") } if cfg.MaxPacketMsgPayloadSize < 0 { 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") } if cfg.RecvRate < 0 { return errors.New("recv_rate can't be negative") } return nil } // FuzzConnConfig is a FuzzedConnection configuration. type FuzzConnConfig struct { Mode int MaxDelay time.Duration ProbDropRW float64 ProbDropConn float64 ProbSleep float64 } // DefaultFuzzConnConfig returns the default config. func DefaultFuzzConnConfig() *FuzzConnConfig { return &FuzzConnConfig{ Mode: FuzzModeDrop, MaxDelay: 3 * time.Second, ProbDropRW: 0.2, ProbDropConn: 0.00, ProbSleep: 0.00, } } //----------------------------------------------------------------------------- // MempoolConfig // MempoolConfig defines the configuration options for the Tendermint mempool type MempoolConfig struct { RootDir string `mapstructure:"home"` Recheck bool `mapstructure:"recheck"` Broadcast bool `mapstructure:"broadcast"` WalPath string `mapstructure:"wal_dir"` Size int `mapstructure:"size"` MaxTxsBytes int64 `mapstructure:"max_txs_bytes"` CacheSize int `mapstructure:"cache_size"` } // DefaultMempoolConfig returns a default configuration for the Tendermint mempool func DefaultMempoolConfig() *MempoolConfig { return &MempoolConfig{ Recheck: true, Broadcast: true, WalPath: "", // Each signature verification takes .5ms, Size reduced until we implement // ABCI Recheck Size: 5000, MaxTxsBytes: 1024 * 1024 * 1024, // 1GB CacheSize: 10000, } } // TestMempoolConfig returns a configuration for testing the Tendermint mempool func TestMempoolConfig() *MempoolConfig { cfg := DefaultMempoolConfig() cfg.CacheSize = 1000 return cfg } // WalDir returns the full path to the mempool's write-ahead log func (cfg *MempoolConfig) WalDir() string { return rootify(cfg.WalPath, cfg.RootDir) } // WalEnabled returns true if the WAL is enabled. func (cfg *MempoolConfig) WalEnabled() bool { return cfg.WalPath != "" } // ValidateBasic performs basic validation (checking param bounds, etc.) and // returns an error if any check fails. func (cfg *MempoolConfig) ValidateBasic() error { if cfg.Size < 0 { return errors.New("size can't be negative") } if cfg.MaxTxsBytes < 0 { return errors.New("max_txs_bytes can't be negative") } if cfg.CacheSize < 0 { return errors.New("cache_size can't be negative") } return nil } //----------------------------------------------------------------------------- // ConsensusConfig // ConsensusConfig defines the configuration for the Tendermint consensus service, // including timeouts and details about the WAL and the block structure. type ConsensusConfig struct { RootDir string `mapstructure:"home"` WalPath string `mapstructure:"wal_file"` walFile string // overrides WalPath if set TimeoutPropose time.Duration `mapstructure:"timeout_propose"` TimeoutProposeDelta time.Duration `mapstructure:"timeout_propose_delta"` TimeoutPrevote time.Duration `mapstructure:"timeout_prevote"` TimeoutPrevoteDelta time.Duration `mapstructure:"timeout_prevote_delta"` TimeoutPrecommit time.Duration `mapstructure:"timeout_precommit"` TimeoutPrecommitDelta time.Duration `mapstructure:"timeout_precommit_delta"` 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"` // EmptyBlocks mode and possible interval between empty blocks 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"` } // DefaultConsensusConfig returns a default configuration for the consensus service func DefaultConsensusConfig() *ConsensusConfig { return &ConsensusConfig{ WalPath: filepath.Join(defaultDataDir, "cs.wal", "wal"), TimeoutPropose: 3000 * time.Millisecond, TimeoutProposeDelta: 500 * time.Millisecond, TimeoutPrevote: 1000 * time.Millisecond, TimeoutPrevoteDelta: 500 * time.Millisecond, TimeoutPrecommit: 1000 * time.Millisecond, TimeoutPrecommitDelta: 500 * time.Millisecond, TimeoutCommit: 1000 * time.Millisecond, SkipTimeoutCommit: false, CreateEmptyBlocks: true, CreateEmptyBlocksInterval: 0 * time.Second, PeerGossipSleepDuration: 100 * time.Millisecond, PeerQueryMaj23SleepDuration: 2000 * time.Millisecond, } } // TestConsensusConfig returns a configuration for testing the consensus service func TestConsensusConfig() *ConsensusConfig { cfg := DefaultConsensusConfig() cfg.TimeoutPropose = 40 * time.Millisecond cfg.TimeoutProposeDelta = 1 * time.Millisecond cfg.TimeoutPrevote = 10 * time.Millisecond cfg.TimeoutPrevoteDelta = 1 * time.Millisecond cfg.TimeoutPrecommit = 10 * time.Millisecond cfg.TimeoutPrecommitDelta = 1 * time.Millisecond cfg.TimeoutCommit = 10 * time.Millisecond cfg.SkipTimeoutCommit = true cfg.PeerGossipSleepDuration = 5 * time.Millisecond cfg.PeerQueryMaj23SleepDuration = 250 * time.Millisecond return cfg } // WaitForTxs returns true if the consensus should wait for transactions before entering the propose step func (cfg *ConsensusConfig) WaitForTxs() bool { return !cfg.CreateEmptyBlocks || cfg.CreateEmptyBlocksInterval > 0 } // Propose returns the amount of time to wait for a proposal func (cfg *ConsensusConfig) Propose(round int) time.Duration { return time.Duration( cfg.TimeoutPropose.Nanoseconds()+cfg.TimeoutProposeDelta.Nanoseconds()*int64(round), ) * time.Nanosecond } // Prevote returns the amount of time to wait for straggler votes after receiving any +2/3 prevotes func (cfg *ConsensusConfig) Prevote(round int) time.Duration { return time.Duration( cfg.TimeoutPrevote.Nanoseconds()+cfg.TimeoutPrevoteDelta.Nanoseconds()*int64(round), ) * time.Nanosecond } // Precommit returns the amount of time to wait for straggler votes after receiving any +2/3 precommits func (cfg *ConsensusConfig) Precommit(round int) time.Duration { return time.Duration( cfg.TimeoutPrecommit.Nanoseconds()+cfg.TimeoutPrecommitDelta.Nanoseconds()*int64(round), ) * time.Nanosecond } // Commit returns the amount of time to wait for straggler votes after receiving +2/3 precommits for a single block (ie. a commit). func (cfg *ConsensusConfig) Commit(t time.Time) time.Time { return t.Add(cfg.TimeoutCommit) } // WalFile returns the full path to the write-ahead log file func (cfg *ConsensusConfig) WalFile() string { if cfg.walFile != "" { return cfg.walFile } return rootify(cfg.WalPath, cfg.RootDir) } // SetWalFile sets the path to the write-ahead log file func (cfg *ConsensusConfig) SetWalFile(walFile string) { cfg.walFile = walFile } // ValidateBasic performs basic validation (checking param bounds, etc.) and // 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") } if cfg.TimeoutProposeDelta < 0 { return errors.New("timeout_propose_delta can't be negative") } if cfg.TimeoutPrevote < 0 { return errors.New("timeout_prevote can't be negative") } if cfg.TimeoutPrevoteDelta < 0 { return errors.New("timeout_prevote_delta can't be negative") } if cfg.TimeoutPrecommit < 0 { return errors.New("timeout_precommit can't be negative") } if cfg.TimeoutPrecommitDelta < 0 { return errors.New("timeout_precommit_delta can't be negative") } if cfg.TimeoutCommit < 0 { return errors.New("timeout_commit can't be negative") } if cfg.CreateEmptyBlocksInterval < 0 { 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") } if cfg.PeerQueryMaj23SleepDuration < 0 { return errors.New("peer_query_maj23_sleep_duration can't be negative") } return nil } //----------------------------------------------------------------------------- // TxIndexConfig // TxIndexConfig defines the configuration for the transaction indexer, // including tags to index. type TxIndexConfig struct { // What indexer to use for transactions // // Options: // 1) "null" // 2) "kv" (default) - the simplest possible indexer, backed by key-value storage (defaults to levelDB; see DBBackend). Indexer string `mapstructure:"indexer"` // Comma-separated list of tags to index (by default the only tag is "tx.hash") // // You can also index transactions by height by adding "tx.height" tag here. // // It's recommended to index only a subset of tags due to possible memory // bloat. This is, of course, depends on the indexer's DB and the volume of // transactions. IndexTags string `mapstructure:"index_tags"` // When set to true, tells indexer to index all tags (predefined tags: // "tx.hash", "tx.height" and all tags from DeliverTx responses). // // Note this may be not desirable (see the comment above). IndexTags has a // precedence over IndexAllTags (i.e. when given both, IndexTags will be // indexed). IndexAllTags bool `mapstructure:"index_all_tags"` } // DefaultTxIndexConfig returns a default configuration for the transaction indexer. func DefaultTxIndexConfig() *TxIndexConfig { return &TxIndexConfig{ Indexer: "kv", IndexTags: "", IndexAllTags: false, } } // TestTxIndexConfig returns a default configuration for the transaction indexer. func TestTxIndexConfig() *TxIndexConfig { return DefaultTxIndexConfig() } //----------------------------------------------------------------------------- // InstrumentationConfig // InstrumentationConfig defines the configuration for metrics reporting. type InstrumentationConfig struct { // When true, Prometheus metrics are served under /metrics on // PrometheusListenAddr. // Check out the documentation for the list of available metrics. Prometheus bool `mapstructure:"prometheus"` // Address to listen for Prometheus collector(s) connections. 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"` // Instrumentation namespace. Namespace string `mapstructure:"namespace"` } // DefaultInstrumentationConfig returns a default configuration for metrics // reporting. func DefaultInstrumentationConfig() *InstrumentationConfig { return &InstrumentationConfig{ Prometheus: false, PrometheusListenAddr: ":26660", MaxOpenConnections: 3, Namespace: "tendermint", } } // TestInstrumentationConfig returns a default configuration for metrics // reporting. func TestInstrumentationConfig() *InstrumentationConfig { return DefaultInstrumentationConfig() } // ValidateBasic performs basic validation (checking param bounds, etc.) and // 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 nil } //----------------------------------------------------------------------------- // Utils // helper function to make config creation independent of root dir func rootify(path, root string) string { if filepath.IsAbs(path) { return path } return filepath.Join(root, path) } //----------------------------------------------------------------------------- // Moniker var defaultMoniker = getDefaultMoniker() // getDefaultMoniker returns a default moniker, which is the host name. If runtime // fails to get the host name, "anonymous" will be returned. func getDefaultMoniker() string { moniker, err := os.Hostname() if err != nil { moniker = "anonymous" } return moniker }