Browse Source

fixes from review

pull/1015/head
Ethan Buchman 7 years ago
parent
commit
1d6f00859d
13 changed files with 68 additions and 69 deletions
  1. +4
    -8
      blockchain/reactor_test.go
  2. +3
    -6
      consensus/common_test.go
  3. +1
    -5
      consensus/replay.go
  4. +1
    -3
      consensus/replay_file.go
  5. +2
    -3
      consensus/replay_test.go
  6. +1
    -1
      consensus/wal_generator.go
  7. +1
    -2
      evidence/pool.go
  8. +5
    -10
      node/node.go
  9. +21
    -14
      state/execution.go
  10. +1
    -10
      state/execution_test.go
  11. +1
    -1
      state/state.go
  12. +2
    -2
      state/state_test.go
  13. +25
    -4
      state/store.go

+ 4
- 8
blockchain/reactor_test.go View File

@ -10,6 +10,7 @@ import (
cfg "github.com/tendermint/tendermint/config" cfg "github.com/tendermint/tendermint/config"
"github.com/tendermint/tendermint/p2p" "github.com/tendermint/tendermint/p2p"
"github.com/tendermint/tendermint/proxy"
sm "github.com/tendermint/tendermint/state" sm "github.com/tendermint/tendermint/state"
"github.com/tendermint/tendermint/types" "github.com/tendermint/tendermint/types"
) )
@ -17,12 +18,7 @@ import (
func makeStateAndBlockStore(logger log.Logger) (sm.State, *BlockStore) { func makeStateAndBlockStore(logger log.Logger) (sm.State, *BlockStore) {
config := cfg.ResetTestRoot("blockchain_reactor_test") config := cfg.ResetTestRoot("blockchain_reactor_test")
blockStore := NewBlockStore(dbm.NewMemDB()) blockStore := NewBlockStore(dbm.NewMemDB())
// Get State
stateDB := dbm.NewMemDB()
state, _ := sm.GetState(stateDB, config.GenesisFile())
sm.SaveState(stateDB, state)
state, _ := sm.LoadStateFromDBOrGenesisFile(dbm.NewMemDB(), config.GenesisFile())
return state, blockStore return state, blockStore
} }
@ -31,8 +27,8 @@ func newBlockchainReactor(logger log.Logger, maxBlockHeight int64) *BlockchainRe
// Make the blockchainReactor itself // Make the blockchainReactor itself
fastSync := true fastSync := true
blockExec := sm.NewBlockExecutor(dbm.NewMemDB(), log.TestingLogger(),
types.NopEventBus{}, nil, types.MockMempool{}, types.MockEvidencePool{})
var nilApp proxy.AppConnConsensus
blockExec := sm.NewBlockExecutor(dbm.NewMemDB(), log.TestingLogger(), nilApp, types.MockMempool{}, types.MockEvidencePool{})
bcReactor := NewBlockchainReactor(state.Copy(), blockExec, blockStore, fastSync) bcReactor := NewBlockchainReactor(state.Copy(), blockExec, blockStore, fastSync)
bcReactor.SetLogger(logger.With("module", "blockchain")) bcReactor.SetLogger(logger.With("module", "blockchain"))


+ 3
- 6
consensus/common_test.go View File

@ -265,8 +265,7 @@ func newConsensusStateWithConfigAndBlockStore(thisConfig *cfg.Config, state sm.S
// Make ConsensusReactor // Make ConsensusReactor
stateDB := dbm.NewMemDB() // XXX !! stateDB := dbm.NewMemDB() // XXX !!
blockExec := sm.NewBlockExecutor(stateDB, log.TestingLogger(),
types.NopEventBus{}, proxyAppConnCon, mempool, evpool)
blockExec := sm.NewBlockExecutor(stateDB, log.TestingLogger(), proxyAppConnCon, mempool, evpool)
cs := NewConsensusState(thisConfig.Consensus, state, blockExec, blockStore, mempool, evpool) cs := NewConsensusState(thisConfig.Consensus, state, blockExec, blockStore, mempool, evpool)
cs.SetLogger(log.TestingLogger()) cs.SetLogger(log.TestingLogger())
cs.SetPrivValidator(pv) cs.SetPrivValidator(pv)
@ -356,8 +355,7 @@ func randConsensusNet(nValidators int, testName string, tickerFunc func() Timeou
logger := consensusLogger() logger := consensusLogger()
for i := 0; i < nValidators; i++ { for i := 0; i < nValidators; i++ {
stateDB := dbm.NewMemDB() // each state needs its own db stateDB := dbm.NewMemDB() // each state needs its own db
state, _ := sm.MakeGenesisState(genDoc)
sm.SaveState(stateDB, state)
state, _ := sm.LoadStateFromDBOrGenesisDoc(stateDB, genDoc)
thisConfig := ResetConfig(cmn.Fmt("%s_%d", testName, i)) thisConfig := ResetConfig(cmn.Fmt("%s_%d", testName, i))
for _, opt := range configOpts { for _, opt := range configOpts {
opt(thisConfig) opt(thisConfig)
@ -381,8 +379,7 @@ func randConsensusNetWithPeers(nValidators, nPeers int, testName string, tickerF
logger := consensusLogger() logger := consensusLogger()
for i := 0; i < nPeers; i++ { for i := 0; i < nPeers; i++ {
stateDB := dbm.NewMemDB() // each state needs its own db stateDB := dbm.NewMemDB() // each state needs its own db
state, _ := sm.MakeGenesisState(genDoc)
sm.SaveState(stateDB, state)
state, _ := sm.LoadStateFromDBOrGenesisDoc(stateDB, genDoc)
thisConfig := ResetConfig(cmn.Fmt("%s_%d", testName, i)) thisConfig := ResetConfig(cmn.Fmt("%s_%d", testName, i))
ensureDir(path.Dir(thisConfig.Consensus.WalFile()), 0700) // dir for wal ensureDir(path.Dir(thisConfig.Consensus.WalFile()), 0700) // dir for wal
var privVal types.PrivValidator var privVal types.PrivValidator


+ 1
- 5
consensus/replay.go View File

@ -363,14 +363,10 @@ func (h *Handshaker) replayBlocks(state sm.State, proxyApp proxy.AppConns, appBl
// ApplyBlock on the proxyApp with the last block. // ApplyBlock on the proxyApp with the last block.
func (h *Handshaker) replayBlock(state sm.State, height int64, proxyApp proxy.AppConnConsensus) (sm.State, error) { func (h *Handshaker) replayBlock(state sm.State, height int64, proxyApp proxy.AppConnConsensus) (sm.State, error) {
mempool := types.MockMempool{}
evpool := types.MockEvidencePool{}
block := h.store.LoadBlock(height) block := h.store.LoadBlock(height)
meta := h.store.LoadBlockMeta(height) meta := h.store.LoadBlockMeta(height)
blockExec := sm.NewBlockExecutor(h.stateDB, h.logger,
types.NopEventBus{}, proxyApp, mempool, evpool)
blockExec := sm.NewBlockExecutor(h.stateDB, h.logger, proxyApp, types.MockMempool{}, types.MockEvidencePool{})
var err error var err error
state, err = blockExec.ApplyBlock(state, meta.BlockID, block) state, err = blockExec.ApplyBlock(state, meta.BlockID, block)


+ 1
- 3
consensus/replay_file.go View File

@ -305,9 +305,7 @@ func newConsensusStateForReplay(config cfg.BaseConfig, csConfig *cfg.ConsensusCo
} }
mempool, evpool := types.MockMempool{}, types.MockEvidencePool{} mempool, evpool := types.MockMempool{}, types.MockEvidencePool{}
blockExec := sm.NewBlockExecutor(stateDB, log.TestingLogger(),
types.NopEventBus{}, proxyApp.Consensus(),
mempool, evpool)
blockExec := sm.NewBlockExecutor(stateDB, log.TestingLogger(), proxyApp.Consensus(), mempool, evpool)
consensusState := NewConsensusState(csConfig, state.Copy(), blockExec, consensusState := NewConsensusState(csConfig, state.Copy(), blockExec,
blockStore, mempool, evpool) blockStore, mempool, evpool)


+ 2
- 3
consensus/replay_test.go View File

@ -53,7 +53,7 @@ func init() {
func startNewConsensusStateAndWaitForBlock(t *testing.T, lastBlockHeight int64, blockDB dbm.DB, stateDB dbm.DB) { func startNewConsensusStateAndWaitForBlock(t *testing.T, lastBlockHeight int64, blockDB dbm.DB, stateDB dbm.DB) {
logger := log.TestingLogger() logger := log.TestingLogger()
state, _ := sm.GetState(stateDB, consensusReplayConfig.GenesisFile())
state, _ := sm.LoadStateFromDBOrGenesisFile(stateDB, consensusReplayConfig.GenesisFile())
privValidator := loadPrivValidator(consensusReplayConfig) privValidator := loadPrivValidator(consensusReplayConfig)
cs := newConsensusStateWithConfigAndBlockStore(consensusReplayConfig, state, privValidator, dummy.NewDummyApplication(), blockDB) cs := newConsensusStateWithConfigAndBlockStore(consensusReplayConfig, state, privValidator, dummy.NewDummyApplication(), blockDB)
cs.SetLogger(logger) cs.SetLogger(logger)
@ -394,8 +394,7 @@ func testHandshakeReplay(t *testing.T, nBlocks int, mode uint) {
func applyBlock(stateDB dbm.DB, st sm.State, blk *types.Block, proxyApp proxy.AppConns) sm.State { func applyBlock(stateDB dbm.DB, st sm.State, blk *types.Block, proxyApp proxy.AppConns) sm.State {
testPartSize := st.ConsensusParams.BlockPartSizeBytes testPartSize := st.ConsensusParams.BlockPartSizeBytes
blockExec := sm.NewBlockExecutor(stateDB, log.TestingLogger(),
types.NopEventBus{}, proxyApp.Consensus(), mempool, evpool)
blockExec := sm.NewBlockExecutor(stateDB, log.TestingLogger(), proxyApp.Consensus(), mempool, evpool)
blkID := types.BlockID{blk.Hash(), blk.MakePartSet(testPartSize).Header()} blkID := types.BlockID{blk.Hash(), blk.MakePartSet(testPartSize).Header()}
newState, err := blockExec.ApplyBlock(st, blkID, blk) newState, err := blockExec.ApplyBlock(st, blkID, blk)


+ 1
- 1
consensus/wal_generator.go View File

@ -67,7 +67,7 @@ func WALWithNBlocks(numBlocks int) (data []byte, err error) {
defer eventBus.Stop() defer eventBus.Stop()
mempool := types.MockMempool{} mempool := types.MockMempool{}
evpool := types.MockEvidencePool{} evpool := types.MockEvidencePool{}
blockExec := sm.NewBlockExecutor(stateDB, log.TestingLogger(), types.NopEventBus{}, proxyApp.Consensus(), mempool, evpool)
blockExec := sm.NewBlockExecutor(stateDB, log.TestingLogger(), proxyApp.Consensus(), mempool, evpool)
consensusState := NewConsensusState(config.Consensus, state.Copy(), blockExec, blockStore, mempool, evpool) consensusState := NewConsensusState(config.Consensus, state.Copy(), blockExec, blockStore, mempool, evpool)
consensusState.SetLogger(logger) consensusState.SetLogger(logger)
consensusState.SetEventBus(eventBus) consensusState.SetEventBus(eventBus)


+ 1
- 2
evidence/pool.go View File

@ -27,8 +27,7 @@ func NewEvidencePool(params types.EvidenceParams, evidenceStore *EvidenceStore,
params: params, params: params,
logger: log.NewNopLogger(), logger: log.NewNopLogger(),
evidenceStore: evidenceStore, evidenceStore: evidenceStore,
// state: *state,
evidenceChan: make(chan types.Evidence),
evidenceChan: make(chan types.Evidence),
} }
return evpool return evpool
} }


+ 5
- 10
node/node.go View File

@ -138,6 +138,7 @@ func NewNode(config *cfg.Config,
} }
// Get genesis doc // Get genesis doc
// TODO: move to state package?
genDoc, err := loadGenesisDoc(stateDB) genDoc, err := loadGenesisDoc(stateDB)
if err != nil { if err != nil {
genDoc, err = genesisDocProvider() genDoc, err = genesisDocProvider()
@ -149,13 +150,9 @@ func NewNode(config *cfg.Config,
saveGenesisDoc(stateDB, genDoc) saveGenesisDoc(stateDB, genDoc)
} }
state := sm.LoadState(stateDB)
if state.IsEmpty() {
state, err = sm.MakeGenesisState(genDoc)
if err != nil {
return nil, err
}
sm.SaveState(stateDB, state)
state, err := sm.LoadStateFromDBOrGenesisDoc(stateDB, genDoc)
if err != nil {
return nil, err
} }
// Create the proxyApp, which manages connections (consensus, mempool, query) // Create the proxyApp, which manages connections (consensus, mempool, query)
@ -218,9 +215,7 @@ func NewNode(config *cfg.Config,
blockExecLogger := logger.With("module", "state") blockExecLogger := logger.With("module", "state")
// make block executor for consensus and blockchain reactors to execute blocks // make block executor for consensus and blockchain reactors to execute blocks
blockExec := sm.NewBlockExecutor(stateDB, blockExecLogger,
types.NopEventBus{}, proxyApp.Consensus(),
mempool, evidencePool)
blockExec := sm.NewBlockExecutor(stateDB, blockExecLogger, proxyApp.Consensus(), mempool, evidencePool)
// Make BlockchainReactor // Make BlockchainReactor
bcReactor := bc.NewBlockchainReactor(state.Copy(), blockExec, blockStore, fastSync) bcReactor := bc.NewBlockchainReactor(state.Copy(), blockExec, blockStore, fastSync)


+ 21
- 14
state/execution.go View File

@ -20,34 +20,41 @@ import (
// BlockExecutor provides the context and accessories for properly executing a block. // BlockExecutor provides the context and accessories for properly executing a block.
type BlockExecutor struct { type BlockExecutor struct {
db dbm.DB
logger log.Logger
// save state, validators, consensus params, abci responses here
db dbm.DB
// execute the app against this
proxyApp proxy.AppConnConsensus
// tx events
txEventPublisher types.TxEventPublisher txEventPublisher types.TxEventPublisher
proxyApp proxy.AppConnConsensus
// update these with block results after commit
mempool types.Mempool mempool types.Mempool
evpool types.EvidencePool evpool types.EvidencePool
}
func (blockExec *BlockExecutor) SetTxEventPublisher(txEventPublisher types.TxEventPublisher) {
blockExec.txEventPublisher = txEventPublisher
logger log.Logger
} }
// NewBlockExecutor returns a new BlockExecutor. // NewBlockExecutor returns a new BlockExecutor.
func NewBlockExecutor(db dbm.DB, logger log.Logger,
txEventer types.TxEventPublisher, proxyApp proxy.AppConnConsensus,
func NewBlockExecutor(db dbm.DB, logger log.Logger, proxyApp proxy.AppConnConsensus,
mempool types.Mempool, evpool types.EvidencePool) *BlockExecutor { mempool types.Mempool, evpool types.EvidencePool) *BlockExecutor {
return &BlockExecutor{ return &BlockExecutor{
db,
logger,
txEventer,
proxyApp,
mempool,
evpool,
db: db,
proxyApp: proxyApp,
txEventPublisher: types.NopEventBus{},
mempool: mempool,
evpool: evpool,
logger: logger,
} }
} }
// SetTxEventPublisher - set the transaction event publisher. If not called,
// it defaults to types.NopEventBus.
func (blockExec *BlockExecutor) SetTxEventPublisher(txEventPublisher types.TxEventPublisher) {
blockExec.txEventPublisher = txEventPublisher
}
// ApplyBlock validates the block against the state, executes it against the app, // ApplyBlock validates the block against the state, executes it against the app,
// commits it, and saves the block and state. It's the only function that needs to be called // commits it, and saves the block and state. It's the only function that needs to be called
// from outside this package to process and commit an entire block. // from outside this package to process and commit an entire block.


+ 1
- 10
state/execution_test.go View File

@ -32,8 +32,7 @@ func TestApplyBlock(t *testing.T) {
state, stateDB := state(), dbm.NewMemDB() state, stateDB := state(), dbm.NewMemDB()
blockExec := NewBlockExecutor(stateDB, log.TestingLogger(),
types.NopEventBus{}, proxyApp.Consensus(),
blockExec := NewBlockExecutor(stateDB, log.TestingLogger(), proxyApp.Consensus(),
types.MockMempool{}, types.MockEvidencePool{}) types.MockMempool{}, types.MockEvidencePool{})
block := makeBlock(state, 1) block := makeBlock(state, 1)
@ -56,14 +55,6 @@ func TestBeginBlockAbsentValidators(t *testing.T) {
state := state() state := state()
// there were 2 validators
/*val1PrivKey := crypto.GenPrivKeyEd25519()
val2PrivKey := crypto.GenPrivKeyEd25519()
lastValidators := types.NewValidatorSet([]*types.Validator{
types.NewValidator(val1PrivKey.PubKey(), 10),
types.NewValidator(val2PrivKey.PubKey(), 5),
})*/
prevHash := state.LastBlockID.Hash prevHash := state.LastBlockID.Hash
prevParts := types.PartSetHeader{} prevParts := types.PartSetHeader{}
prevBlockID := types.BlockID{prevHash, prevParts} prevBlockID := types.BlockID{prevHash, prevParts}


+ 1
- 1
state/state.go View File

@ -23,7 +23,7 @@ var (
// including the last validator set and the consensus params. // including the last validator set and the consensus params.
// All fields are exposed so the struct can be easily serialized, // All fields are exposed so the struct can be easily serialized,
// but none of them should be mutated directly. // but none of them should be mutated directly.
// Instead, use state.Copy() ro state.NextState(...).
// Instead, use state.Copy() or state.NextState(...).
// NOTE: not goroutine-safe. // NOTE: not goroutine-safe.
type State struct { type State struct {
// Immutable // Immutable


+ 2
- 2
state/state_test.go View File

@ -23,8 +23,8 @@ import (
func setupTestCase(t *testing.T) (func(t *testing.T), dbm.DB, State) { func setupTestCase(t *testing.T) (func(t *testing.T), dbm.DB, State) {
config := cfg.ResetTestRoot("state_") config := cfg.ResetTestRoot("state_")
stateDB := dbm.NewDB("state", config.DBBackend, config.DBDir()) stateDB := dbm.NewDB("state", config.DBBackend, config.DBDir())
state, err := GetState(stateDB, config.GenesisFile())
assert.NoError(t, err, "expected no error on GetState")
state, err := LoadStateFromDBOrGenesisFile(stateDB, config.GenesisFile())
assert.NoError(t, err, "expected no error on LoadStateFromDBOrGenesisFile")
tearDown := func(t *testing.T) {} tearDown := func(t *testing.T) {}


state/db.go → state/store.go View File


Loading…
Cancel
Save