github.com/tri-stone/burrow@v0.25.0/consensus/tendermint/tendermint.go (about)

     1  package tendermint
     2  
     3  import (
     4  	"os"
     5  	"path"
     6  
     7  	"github.com/hyperledger/burrow/binary"
     8  	"github.com/hyperledger/burrow/consensus/abci"
     9  	"github.com/hyperledger/burrow/crypto"
    10  	"github.com/hyperledger/burrow/genesis"
    11  	"github.com/hyperledger/burrow/logging"
    12  	"github.com/hyperledger/burrow/logging/structure"
    13  	"github.com/tendermint/tendermint/config"
    14  	"github.com/tendermint/tendermint/crypto/ed25519"
    15  	dbm "github.com/tendermint/tendermint/libs/db"
    16  	"github.com/tendermint/tendermint/node"
    17  	"github.com/tendermint/tendermint/p2p"
    18  	"github.com/tendermint/tendermint/proxy"
    19  	tmTypes "github.com/tendermint/tendermint/types"
    20  )
    21  
    22  // Serves as a wrapper around the Tendermint node's closeable resources (database connections)
    23  type Node struct {
    24  	*node.Node
    25  	closers []interface {
    26  		Close()
    27  	}
    28  }
    29  
    30  func DBProvider(ID string, backendType dbm.DBBackendType, dbDir string) dbm.DB {
    31  	return dbm.NewDB(ID, backendType, dbDir)
    32  }
    33  
    34  // Since Tendermint doesn't close its DB connections
    35  func (n *Node) DBProvider(ctx *node.DBContext) (dbm.DB, error) {
    36  	db := DBProvider(ctx.ID, dbm.DBBackendType(ctx.Config.DBBackend), ctx.Config.DBDir())
    37  	n.closers = append(n.closers, db)
    38  	return db, nil
    39  }
    40  
    41  func (n *Node) Close() {
    42  	for _, closer := range n.closers {
    43  		closer.Close()
    44  	}
    45  }
    46  
    47  func NewNode(conf *config.Config, privValidator tmTypes.PrivValidator, genesisDoc *tmTypes.GenesisDoc,
    48  	app *abci.App, metricsProvider node.MetricsProvider, marmotNodeKey *crypto.PrivateKey, logger *logging.Logger) (*Node, error) {
    49  
    50  	var err error
    51  	// disable Tendermint's RPC
    52  	conf.RPC.ListenAddress = ""
    53  
    54  	var nodeKey *p2p.NodeKey
    55  	if marmotNodeKey != nil && marmotNodeKey.CurveType == crypto.CurveTypeEd25519 {
    56  		var pkey ed25519.PrivKeyEd25519
    57  		copy(pkey[:], marmotNodeKey.PrivateKey)
    58  		nodeKey = &p2p.NodeKey{PrivKey: pkey}
    59  	} else {
    60  		err = os.MkdirAll(path.Dir(conf.NodeKeyFile()), 0777)
    61  		if err != nil {
    62  			return nil, err
    63  		}
    64  
    65  		nodeKey, err = p2p.LoadOrGenNodeKey(conf.NodeKeyFile())
    66  		if err != nil {
    67  			return nil, err
    68  		}
    69  	}
    70  
    71  	nde := &Node{}
    72  	nde.Node, err = node.NewNode(conf, privValidator,
    73  		nodeKey, proxy.NewLocalClientCreator(app),
    74  		func() (*tmTypes.GenesisDoc, error) {
    75  			return genesisDoc, nil
    76  		},
    77  		nde.DBProvider,
    78  		metricsProvider,
    79  		NewLogger(logger.WithPrefix(structure.ComponentKey, structure.Tendermint).
    80  			With(structure.ScopeKey, "tendermint.NewNode")))
    81  	if err != nil {
    82  		return nil, err
    83  	}
    84  	app.SetMempoolLocker(nde.MempoolReactor().Mempool)
    85  	return nde, nil
    86  }
    87  
    88  func DeriveGenesisDoc(burrowGenesisDoc *genesis.GenesisDoc, appHash []byte) *tmTypes.GenesisDoc {
    89  	validators := make([]tmTypes.GenesisValidator, len(burrowGenesisDoc.Validators))
    90  	for i, validator := range burrowGenesisDoc.Validators {
    91  		validators[i] = tmTypes.GenesisValidator{
    92  			PubKey: validator.PublicKey.TendermintPubKey(),
    93  			Name:   validator.Name,
    94  			Power:  int64(validator.Amount),
    95  		}
    96  	}
    97  	consensusParams := tmTypes.DefaultConsensusParams()
    98  	// This is the smallest increment we can use to get a strictly increasing sequence
    99  	// of block time - we set it low to avoid skew
   100  	// if the BlockTimeIota is longer than the average block time
   101  	consensusParams.Block.TimeIotaMs = 1
   102  
   103  	return &tmTypes.GenesisDoc{
   104  		ChainID:         burrowGenesisDoc.ChainID(),
   105  		GenesisTime:     burrowGenesisDoc.GenesisTime,
   106  		Validators:      validators,
   107  		AppHash:         appHash,
   108  		ConsensusParams: consensusParams,
   109  	}
   110  }
   111  
   112  func NewNodeInfo(ni p2p.DefaultNodeInfo) *NodeInfo {
   113  	address, _ := crypto.AddressFromHexString(string(ni.ID()))
   114  	return &NodeInfo{
   115  		ID:            address,
   116  		Moniker:       ni.Moniker,
   117  		ListenAddress: ni.ListenAddr,
   118  		Version:       ni.Version,
   119  		Channels:      binary.HexBytes(ni.Channels),
   120  		Network:       ni.Network,
   121  		RPCAddress:    ni.Other.RPCAddress,
   122  		TxIndex:       ni.Other.TxIndex,
   123  	}
   124  }