cmn "github.com/tendermint/tmlibs/common"
)
-var initFilesCmd = &cobra.Command{
+var initFilesCmd = &cobra.Command {
Use: "init",
Short: "Initialize blockchain",
Run: initFiles,
}
func initFiles(cmd *cobra.Command, args []string) {
- privValFile := config.PrivValidatorFile()
- if _, err := os.Stat(privValFile); os.IsNotExist(err) {
- privValidator := types.GenPrivValidator()
- privValidator.SetFile(privValFile)
- privValidator.Save()
-
- genFile := config.GenesisFile()
-
- if _, err := os.Stat(genFile); os.IsNotExist(err) {
- genDoc := types.GenesisDoc{
- ChainID: cmn.Fmt("chain0"),
- }
- genDoc.Validators = []types.GenesisValidator{types.GenesisValidator{
- PubKey: privValidator.PubKey,
- Amount: 10,
- }}
-
- genDoc.SaveAs(genFile)
+ genFile := config.GenesisFile()
+
+ if _, err := os.Stat(genFile); os.IsNotExist(err) {
+ genDoc := types.GenesisDoc{
+ ChainID: cmn.Fmt("bytom"),
}
- logger.Info("Initialized tendermint", "genesis", config.GenesisFile(), "priv_validator", config.PrivValidatorFile())
- } else {
- logger.Info("Already initialized", "priv_validator", config.PrivValidatorFile())
+ genDoc.SaveAs(genFile)
}
+
+ logger.Info("Initialized bytom", "genesis", config.GenesisFile())
}
import (
"fmt"
"path/filepath"
- "time"
+ //"time"
- "github.com/bytom/types"
+ //"github.com/bytom/types"
)
type Config struct {
// Options for services
RPC *RPCConfig `mapstructure:"rpc"`
P2P *P2PConfig `mapstructure:"p2p"`
- Mempool *MempoolConfig `mapstructure:"mempool"`
- Consensus *ConsensusConfig `mapstructure:"consensus"`
}
func DefaultConfig() *Config {
BaseConfig: DefaultBaseConfig(),
RPC: DefaultRPCConfig(),
P2P: DefaultP2PConfig(),
- Mempool: DefaultMempoolConfig(),
- Consensus: DefaultConsensusConfig(),
}
}
BaseConfig: TestBaseConfig(),
RPC: TestRPCConfig(),
P2P: TestP2PConfig(),
- Mempool: DefaultMempoolConfig(),
- Consensus: TestConsensusConfig(),
}
}
cfg.BaseConfig.RootDir = root
cfg.RPC.RootDir = root
cfg.P2P.RootDir = root
- cfg.Mempool.RootDir = root
- cfg.Consensus.RootDir = root
return cfg
}
//-----------------------------------------------------------------------------
// BaseConfig
-// BaseConfig struct for a Tendermint node
type BaseConfig struct {
// The root directory for all data.
// This should be set in viper so it can unmarshal into this struct
// A custom human readable name for this node
Moniker string `mapstructure:"moniker"`
- // 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"`
-
- // Mechanism to connect to the ABCI application: socket | grpc
- ABCI string `mapstructure:"abci"`
-
// Output level for logging
LogLevel string `mapstructure:"log_level"`
// and verifying their commits
FastSync bool `mapstructure:"fast_sync"`
- // 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
// What indexer to use for transactions
func DefaultBaseConfig() BaseConfig {
return BaseConfig{
Genesis: "genesis.json",
- PrivValidator: "priv_validator.json",
Moniker: "anonymous",
- ProxyApp: "tcp://127.0.0.1:46658",
- ABCI: "socket",
LogLevel: DefaultPackageLogLevels(),
ProfListenAddress: "",
FastSync: true,
func TestBaseConfig() BaseConfig {
conf := DefaultBaseConfig()
- conf.ChainID = "tendermint_test"
- conf.ProxyApp = "dummy"
+ conf.ChainID = "bytom_test"
conf.FastSync = false
conf.DBBackend = "memdb"
return conf
return rootify(b.Genesis, b.RootDir)
}
-func (b BaseConfig) PrivValidatorFile() string {
- return rootify(b.PrivValidator, b.RootDir)
-}
-
func (b BaseConfig) DBDir() string {
return rootify(b.DBPath, b.RootDir)
}
}
//-----------------------------------------------------------------------------
-// MempoolConfig
-
-type MempoolConfig struct {
- RootDir string `mapstructure:"home"`
- Recheck bool `mapstructure:"recheck"`
- RecheckEmpty bool `mapstructure:"recheck_empty"`
- Broadcast bool `mapstructure:"broadcast"`
- WalPath string `mapstructure:"wal_dir"`
-}
-
-func DefaultMempoolConfig() *MempoolConfig {
- return &MempoolConfig{
- Recheck: true,
- RecheckEmpty: true,
- Broadcast: true,
- WalPath: "data/mempool.wal",
- }
-}
-
-func (m *MempoolConfig) WalDir() string {
- return rootify(m.WalPath, m.RootDir)
-}
-
-//-----------------------------------------------------------------------------
-// ConsensusConfig
-
-// ConsensusConfig holds timeouts and details about the WAL, the block structure,
-// and timeouts in the consensus protocol.
-type ConsensusConfig struct {
- RootDir string `mapstructure:"home"`
- WalPath string `mapstructure:"wal_file"`
- WalLight bool `mapstructure:"wal_light"`
- walFile string // overrides WalPath if set
-
- // All timeouts are in ms
- TimeoutPropose int `mapstructure:"timeout_propose"`
- TimeoutProposeDelta int `mapstructure:"timeout_propose_delta"`
- TimeoutPrevote int `mapstructure:"timeout_prevote"`
- TimeoutPrevoteDelta int `mapstructure:"timeout_prevote_delta"`
- TimeoutPrecommit int `mapstructure:"timeout_precommit"`
- TimeoutPrecommitDelta int `mapstructure:"timeout_precommit_delta"`
- TimeoutCommit int `mapstructure:"timeout_commit"`
-
- // Make progress as soon as we have all the precommits (as if TimeoutCommit = 0)
- SkipTimeoutCommit bool `mapstructure:"skip_timeout_commit"`
-
- // BlockSize
- MaxBlockSizeTxs int `mapstructure:"max_block_size_txs"`
- MaxBlockSizeBytes int `mapstructure:"max_block_size_bytes"`
-
- // TODO: This probably shouldn't be exposed but it makes it
- // easy to write tests for the wal/replay
- BlockPartSize int `mapstructure:"block_part_size"`
-}
-
-// Wait this long for a proposal
-func (cfg *ConsensusConfig) Propose(round int) time.Duration {
- return time.Duration(cfg.TimeoutPropose+cfg.TimeoutProposeDelta*round) * time.Millisecond
-}
-
-// After receiving any +2/3 prevote, wait this long for stragglers
-func (cfg *ConsensusConfig) Prevote(round int) time.Duration {
- return time.Duration(cfg.TimeoutPrevote+cfg.TimeoutPrevoteDelta*round) * time.Millisecond
-}
-
-// After receiving any +2/3 precommits, wait this long for stragglers
-func (cfg *ConsensusConfig) Precommit(round int) time.Duration {
- return time.Duration(cfg.TimeoutPrecommit+cfg.TimeoutPrecommitDelta*round) * time.Millisecond
-}
-
-// After receiving +2/3 precommits for a single block (a commit), wait this long for stragglers in the next height's RoundStepNewHeight
-func (cfg *ConsensusConfig) Commit(t time.Time) time.Time {
- return t.Add(time.Duration(cfg.TimeoutCommit) * time.Millisecond)
-}
-
-func DefaultConsensusConfig() *ConsensusConfig {
- return &ConsensusConfig{
- WalPath: "data/cs.wal/wal",
- WalLight: false,
- TimeoutPropose: 3000,
- TimeoutProposeDelta: 500,
- TimeoutPrevote: 1000,
- TimeoutPrevoteDelta: 500,
- TimeoutPrecommit: 1000,
- TimeoutPrecommitDelta: 500,
- TimeoutCommit: 1000,
- SkipTimeoutCommit: false,
- MaxBlockSizeTxs: 10000,
- MaxBlockSizeBytes: 1, // TODO
- BlockPartSize: types.DefaultBlockPartSize, // TODO: we shouldnt be importing types
- }
-}
-
-func TestConsensusConfig() *ConsensusConfig {
- config := DefaultConsensusConfig()
- config.TimeoutPropose = 2000
- config.TimeoutProposeDelta = 1
- config.TimeoutPrevote = 10
- config.TimeoutPrevoteDelta = 1
- config.TimeoutPrecommit = 10
- config.TimeoutPrecommitDelta = 1
- config.TimeoutCommit = 10
- config.SkipTimeoutCommit = true
- return config
-}
-
-func (c *ConsensusConfig) WalFile() string {
- if c.walFile != "" {
- return c.walFile
- }
- return rootify(c.WalPath, c.RootDir)
-}
-
-func (c *ConsensusConfig) SetWalFile(walFile string) {
- c.walFile = walFile
-}
-
-//-----------------------------------------------------------------------------
// Utils
// helper function to make config creation independent of root dir
// config
config *cfg.Config
- privValidator *types.PrivValidator // local node's validator key
// network
privKey crypto.PrivKeyEd25519 // local node's p2p key
func NewNodeDefault(config *cfg.Config, logger log.Logger) *Node {
- // Get PrivValidator
- privValidator := types.LoadOrGenPrivValidator(config.PrivValidatorFile(), logger)
- return NewNode(config, privValidator, logger)
+ return NewNode(config, logger)
}
func RedirectHandler(next http.Handler) http.Handler {
coreHandler.Set(h)
}
-func NewNode(config *cfg.Config, privValidator *types.PrivValidator, logger log.Logger) *Node {
+func NewNode(config *cfg.Config, logger log.Logger) *Node {
// Get store
tx_db := dbm.NewDB("txdb", config.DBBackend, config.DBDir())
store := txdb.NewStore(tx_db)
node := &Node{
config: config,
- privValidator: privValidator,
privKey: privKey,
sw: sw,
//rpccore.SetConsensusState(n.consensusState)
//rpccore.SetMempool(n.mempoolReactor.Mempool)
rpccore.SetSwitch(n.sw)
- //rpccore.SetPubKey(n.privValidator.PubKey)
//rpccore.SetGenesisDoc(n.genesisDoc)
rpccore.SetAddrBook(n.addrBook)
//rpccore.SetProxyAppQuery(n.proxyApp.Query())
return n.evsw
}
-// XXX: for convenience
-func (n *Node) PrivValidator() *types.PrivValidator {
- return n.privValidator
-}
-
func (n *Node) makeNodeInfo() *p2p.NodeInfo {
nodeInfo := &p2p.NodeInfo{
PubKey: n.privKey.PubKey().Unwrap().(crypto.PubKeyEd25519),
OSDN Git Service
