Browse Source
Merge pull request #1015 from tendermint/state_funcs
state: move methods to funcspull/1016/merge
Ethan Buchman
7 years ago
committed by
GitHub
GitHub
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
27 changed files with 1121 additions and 961 deletions
Split View
Diff Options
-
+21 -2CHANGELOG.md
-
+40 -28blockchain/reactor.go
-
+11 -10blockchain/reactor_test.go
-
+14 -19consensus/common_test.go
-
+1 -1consensus/reactor.go
-
+40 -31consensus/replay.go
-
+12 -8consensus/replay_file.go
-
+34 -38consensus/replay_test.go
-
+19 -37consensus/state.go
-
+4 -4consensus/wal_generator.go
-
+45 -9evidence/pool.go
-
+36 -8evidence/pool_test.go
-
+20 -10evidence/reactor_test.go
-
+4 -2evidence/store_test.go
-
+22 -20node/node.go
-
+2 -2rpc/core/blocks.go
-
+2 -2rpc/core/consensus.go
-
+7 -1rpc/core/pipe.go
-
+203 -200state/execution.go
-
+10 -77state/execution_test.go
-
+30 -385state/state.go
-
+61 -54state/state_test.go
-
+282 -0state/store.go
-
+122 -0state/validation.go
-
+68 -0state/validation_test.go
-
+7 -0types/events.go
-
+4 -13types/services.go
+ 21
- 2
CHANGELOG.md
View File
+ 40
- 28
blockchain/reactor.go
View File
+ 11
- 10
blockchain/reactor_test.go
View File
+ 14
- 19
consensus/common_test.go
View File
+ 1
- 1
consensus/reactor.go
View File
+ 40
- 31
consensus/replay.go
View File
+ 12
- 8
consensus/replay_file.go
View File
+ 34
- 38
consensus/replay_test.go
View File
+ 19
- 37
consensus/state.go
View File
+ 4
- 4
consensus/wal_generator.go
View File
+ 45
- 9
evidence/pool.go
View File
+ 36
- 8
evidence/pool_test.go
View File
+ 20
- 10
evidence/reactor_test.go
View File
+ 4
- 2
evidence/store_test.go
View File
+ 22
- 20
node/node.go
View File
+ 2
- 2
rpc/core/blocks.go
View File
+ 2
- 2
rpc/core/consensus.go
View File
+ 7
- 1
rpc/core/pipe.go
View File
+ 203
- 200
state/execution.go
View File
+ 10
- 77
state/execution_test.go
View File
+ 30
- 385
state/state.go
View File
+ 61
- 54
state/state_test.go
View File
+ 282
- 0
state/store.go
View File
| @ -0,0 +1,282 @@ | |||
| package state | |||
| import ( | |||
| "bytes" | |||
| "fmt" | |||
| abci "github.com/tendermint/abci/types" | |||
| wire "github.com/tendermint/go-wire" | |||
| "github.com/tendermint/tendermint/types" | |||
| cmn "github.com/tendermint/tmlibs/common" | |||
| dbm "github.com/tendermint/tmlibs/db" | |||
| ) | |||
| //------------------------------------------------------------------------ | |||
| func calcValidatorsKey(height int64) []byte { | |||
| return []byte(cmn.Fmt("validatorsKey:%v", height)) | |||
| } | |||
| func calcConsensusParamsKey(height int64) []byte { | |||
| return []byte(cmn.Fmt("consensusParamsKey:%v", height)) | |||
| } | |||
| func calcABCIResponsesKey(height int64) []byte { | |||
| return []byte(cmn.Fmt("abciResponsesKey:%v", height)) | |||
| } | |||
| // LoadStateFromDBOrGenesisFile loads the most recent state from the database, | |||
| // or creates a new one from the given genesisFilePath and persists the result | |||
| // to the database. | |||
| func LoadStateFromDBOrGenesisFile(stateDB dbm.DB, genesisFilePath string) (State, error) { | |||
| state := LoadState(stateDB) | |||
| if state.IsEmpty() { | |||
| var err error | |||
| state, err = MakeGenesisStateFromFile(genesisFilePath) | |||
| if err != nil { | |||
| return state, err | |||
| } | |||
| SaveState(stateDB, state) | |||
| } | |||
| return state, nil | |||
| } | |||
| // LoadStateFromDBOrGenesisDoc loads the most recent state from the database, | |||
| // or creates a new one from the given genesisDoc and persists the result | |||
| // to the database. | |||
| func LoadStateFromDBOrGenesisDoc(stateDB dbm.DB, genesisDoc *types.GenesisDoc) (State, error) { | |||
| state := LoadState(stateDB) | |||
| if state.IsEmpty() { | |||
| var err error | |||
| state, err = MakeGenesisState(genesisDoc) | |||
| if err != nil { | |||
| return state, err | |||
| } | |||
| SaveState(stateDB, state) | |||
| } | |||
| return state, nil | |||
| } | |||
| // LoadState loads the State from the database. | |||
| func LoadState(db dbm.DB) State { | |||
| return loadState(db, stateKey) | |||
| } | |||
| func loadState(db dbm.DB, key []byte) (state State) { | |||
| buf := db.Get(key) | |||
| if len(buf) == 0 { | |||
| return state | |||
| } | |||
| r, n, err := bytes.NewReader(buf), new(int), new(error) | |||
| wire.ReadBinaryPtr(&state, r, 0, n, err) | |||
| if *err != nil { | |||
| // DATA HAS BEEN CORRUPTED OR THE SPEC HAS CHANGED | |||
| cmn.Exit(cmn.Fmt(`LoadState: Data has been corrupted or its spec has changed: | |||
| %v\n`, *err)) | |||
| } | |||
| // TODO: ensure that buf is completely read. | |||
| return state | |||
| } | |||
| // SaveState persists the State, the ValidatorsInfo, and the ConsensusParamsInfo to the database. | |||
| func SaveState(db dbm.DB, s State) { | |||
| saveState(db, s, stateKey) | |||
| } | |||
| func saveState(db dbm.DB, s State, key []byte) { | |||
| nextHeight := s.LastBlockHeight + 1 | |||
| saveValidatorsInfo(db, nextHeight, s.LastHeightValidatorsChanged, s.Validators) | |||
| saveConsensusParamsInfo(db, nextHeight, s.LastHeightConsensusParamsChanged, s.ConsensusParams) | |||
| db.SetSync(stateKey, s.Bytes()) | |||
| } | |||
| //------------------------------------------------------------------------ | |||
| // ABCIResponses retains the responses | |||
| // of the various ABCI calls during block processing. | |||
| // It is persisted to disk for each height before calling Commit. | |||
| type ABCIResponses struct { | |||
| DeliverTx []*abci.ResponseDeliverTx | |||
| EndBlock *abci.ResponseEndBlock | |||
| } | |||
| // NewABCIResponses returns a new ABCIResponses | |||
| func NewABCIResponses(block *types.Block) *ABCIResponses { | |||
| return &ABCIResponses{ | |||
| DeliverTx: make([]*abci.ResponseDeliverTx, block.NumTxs), | |||
| } | |||
| } | |||
| // Bytes serializes the ABCIResponse using go-wire | |||
| func (a *ABCIResponses) Bytes() []byte { | |||
| return wire.BinaryBytes(*a) | |||
| } | |||
| func (a *ABCIResponses) ResultsHash() []byte { | |||
| results := types.NewResults(a.DeliverTx) | |||
| return results.Hash() | |||
| } | |||
| // LoadABCIResponses loads the ABCIResponses for the given height from the database. | |||
| // This is useful for recovering from crashes where we called app.Commit and before we called | |||
| // s.Save(). It can also be used to produce Merkle proofs of the result of txs. | |||
| func LoadABCIResponses(db dbm.DB, height int64) (*ABCIResponses, error) { | |||
| buf := db.Get(calcABCIResponsesKey(height)) | |||
| if len(buf) == 0 { | |||
| return nil, ErrNoABCIResponsesForHeight{height} | |||
| } | |||
| abciResponses := new(ABCIResponses) | |||
| r, n, err := bytes.NewReader(buf), new(int), new(error) | |||
| wire.ReadBinaryPtr(abciResponses, r, 0, n, err) | |||
| if *err != nil { | |||
| // DATA HAS BEEN CORRUPTED OR THE SPEC HAS CHANGED | |||
| cmn.Exit(cmn.Fmt(`LoadABCIResponses: Data has been corrupted or its spec has | |||
| changed: %v\n`, *err)) | |||
| } | |||
| // TODO: ensure that buf is completely read. | |||
| return abciResponses, nil | |||
| } | |||
| // SaveABCIResponses persists the ABCIResponses to the database. | |||
| // This is useful in case we crash after app.Commit and before s.Save(). | |||
| // Responses are indexed by height so they can also be loaded later to produce Merkle proofs. | |||
| func saveABCIResponses(db dbm.DB, height int64, abciResponses *ABCIResponses) { | |||
| db.SetSync(calcABCIResponsesKey(height), abciResponses.Bytes()) | |||
| } | |||
| //----------------------------------------------------------------------------- | |||
| // ValidatorsInfo represents the latest validator set, or the last height it changed | |||
| type ValidatorsInfo struct { | |||
| ValidatorSet *types.ValidatorSet | |||
| LastHeightChanged int64 | |||
| } | |||
| // Bytes serializes the ValidatorsInfo using go-wire | |||
| func (valInfo *ValidatorsInfo) Bytes() []byte { | |||
| return wire.BinaryBytes(*valInfo) | |||
| } | |||
| // LoadValidators loads the ValidatorSet for a given height. | |||
| // Returns ErrNoValSetForHeight if the validator set can't be found for this height. | |||
| func LoadValidators(db dbm.DB, height int64) (*types.ValidatorSet, error) { | |||
| valInfo := loadValidatorsInfo(db, height) | |||
| if valInfo == nil { | |||
| return nil, ErrNoValSetForHeight{height} | |||
| } | |||
| if valInfo.ValidatorSet == nil { | |||
| valInfo = loadValidatorsInfo(db, valInfo.LastHeightChanged) | |||
| if valInfo == nil { | |||
| cmn.PanicSanity(fmt.Sprintf(`Couldn't find validators at height %d as | |||
| last changed from height %d`, valInfo.LastHeightChanged, height)) | |||
| } | |||
| } | |||
| return valInfo.ValidatorSet, nil | |||
| } | |||
| func loadValidatorsInfo(db dbm.DB, height int64) *ValidatorsInfo { | |||
| buf := db.Get(calcValidatorsKey(height)) | |||
| if len(buf) == 0 { | |||
| return nil | |||
| } | |||
| v := new(ValidatorsInfo) | |||
| r, n, err := bytes.NewReader(buf), new(int), new(error) | |||
| wire.ReadBinaryPtr(v, r, 0, n, err) | |||
| if *err != nil { | |||
| // DATA HAS BEEN CORRUPTED OR THE SPEC HAS CHANGED | |||
| cmn.Exit(cmn.Fmt(`LoadValidators: Data has been corrupted or its spec has changed: | |||
| %v\n`, *err)) | |||
| } | |||
| // TODO: ensure that buf is completely read. | |||
| return v | |||
| } | |||
| // saveValidatorsInfo persists the validator set for the next block to disk. | |||
| // It should be called from s.Save(), right before the state itself is persisted. | |||
| // If the validator set did not change after processing the latest block, | |||
| // only the last height for which the validators changed is persisted. | |||
| func saveValidatorsInfo(db dbm.DB, nextHeight, changeHeight int64, valSet *types.ValidatorSet) { | |||
| valInfo := &ValidatorsInfo{ | |||
| LastHeightChanged: changeHeight, | |||
| } | |||
| if changeHeight == nextHeight { | |||
| valInfo.ValidatorSet = valSet | |||
| } | |||
| db.SetSync(calcValidatorsKey(nextHeight), valInfo.Bytes()) | |||
| } | |||
| //----------------------------------------------------------------------------- | |||
| // ConsensusParamsInfo represents the latest consensus params, or the last height it changed | |||
| type ConsensusParamsInfo struct { | |||
| ConsensusParams types.ConsensusParams | |||
| LastHeightChanged int64 | |||
| } | |||
| // Bytes serializes the ConsensusParamsInfo using go-wire | |||
| func (params ConsensusParamsInfo) Bytes() []byte { | |||
| return wire.BinaryBytes(params) | |||
| } | |||
| // LoadConsensusParams loads the ConsensusParams for a given height. | |||
| func LoadConsensusParams(db dbm.DB, height int64) (types.ConsensusParams, error) { | |||
| empty := types.ConsensusParams{} | |||
| paramsInfo := loadConsensusParamsInfo(db, height) | |||
| if paramsInfo == nil { | |||
| return empty, ErrNoConsensusParamsForHeight{height} | |||
| } | |||
| if paramsInfo.ConsensusParams == empty { | |||
| paramsInfo = loadConsensusParamsInfo(db, paramsInfo.LastHeightChanged) | |||
| if paramsInfo == nil { | |||
| cmn.PanicSanity(fmt.Sprintf(`Couldn't find consensus params at height %d as | |||
| last changed from height %d`, paramsInfo.LastHeightChanged, height)) | |||
| } | |||
| } | |||
| return paramsInfo.ConsensusParams, nil | |||
| } | |||
| func loadConsensusParamsInfo(db dbm.DB, height int64) *ConsensusParamsInfo { | |||
| buf := db.Get(calcConsensusParamsKey(height)) | |||
| if len(buf) == 0 { | |||
| return nil | |||
| } | |||
| paramsInfo := new(ConsensusParamsInfo) | |||
| r, n, err := bytes.NewReader(buf), new(int), new(error) | |||
| wire.ReadBinaryPtr(paramsInfo, r, 0, n, err) | |||
| if *err != nil { | |||
| // DATA HAS BEEN CORRUPTED OR THE SPEC HAS CHANGED | |||
| cmn.Exit(cmn.Fmt(`LoadConsensusParams: Data has been corrupted or its spec has changed: | |||
| %v\n`, *err)) | |||
| } | |||
| // TODO: ensure that buf is completely read. | |||
| return paramsInfo | |||
| } | |||
| // saveConsensusParamsInfo persists the consensus params for the next block to disk. | |||
| // It should be called from s.Save(), right before the state itself is persisted. | |||
| // If the consensus params did not change after processing the latest block, | |||
| // only the last height for which they changed is persisted. | |||
| func saveConsensusParamsInfo(db dbm.DB, nextHeight, changeHeight int64, params types.ConsensusParams) { | |||
| paramsInfo := &ConsensusParamsInfo{ | |||
| LastHeightChanged: changeHeight, | |||
| } | |||
| if changeHeight == nextHeight { | |||
| paramsInfo.ConsensusParams = params | |||
| } | |||
| db.SetSync(calcConsensusParamsKey(nextHeight), paramsInfo.Bytes()) | |||
| } | |||
+ 122
- 0
state/validation.go
View File
| @ -0,0 +1,122 @@ | |||
| package state | |||
| import ( | |||
| "bytes" | |||
| "errors" | |||
| "fmt" | |||
| "github.com/tendermint/tendermint/types" | |||
| dbm "github.com/tendermint/tmlibs/db" | |||
| ) | |||
| //----------------------------------------------------- | |||
| // Validate block | |||
| func validateBlock(stateDB dbm.DB, s State, b *types.Block) error { | |||
| // validate internal consistency | |||
| if err := b.ValidateBasic(); err != nil { | |||
| return err | |||
| } | |||
| // validate basic info | |||
| if b.ChainID != s.ChainID { | |||
| return fmt.Errorf("Wrong Block.Header.ChainID. Expected %v, got %v", s.ChainID, b.ChainID) | |||
| } | |||
| if b.Height != s.LastBlockHeight+1 { | |||
| return fmt.Errorf("Wrong Block.Header.Height. Expected %v, got %v", s.LastBlockHeight+1, b.Height) | |||
| } | |||
| /* TODO: Determine bounds for Time | |||
| See blockchain/reactor "stopSyncingDurationMinutes" | |||
| if !b.Time.After(lastBlockTime) { | |||
| return errors.New("Invalid Block.Header.Time") | |||
| } | |||
| */ | |||
| // validate prev block info | |||
| if !b.LastBlockID.Equals(s.LastBlockID) { | |||
| return fmt.Errorf("Wrong Block.Header.LastBlockID. Expected %v, got %v", s.LastBlockID, b.LastBlockID) | |||
| } | |||
| newTxs := int64(len(b.Data.Txs)) | |||
| if b.TotalTxs != s.LastBlockTotalTx+newTxs { | |||
| return fmt.Errorf("Wrong Block.Header.TotalTxs. Expected %v, got %v", s.LastBlockTotalTx+newTxs, b.TotalTxs) | |||
| } | |||
| // validate app info | |||
| if !bytes.Equal(b.AppHash, s.AppHash) { | |||
| return fmt.Errorf("Wrong Block.Header.AppHash. Expected %X, got %v", s.AppHash, b.AppHash) | |||
| } | |||
| if !bytes.Equal(b.ConsensusHash, s.ConsensusParams.Hash()) { | |||
| return fmt.Errorf("Wrong Block.Header.ConsensusHash. Expected %X, got %v", s.ConsensusParams.Hash(), b.ConsensusHash) | |||
| } | |||
| if !bytes.Equal(b.LastResultsHash, s.LastResultsHash) { | |||
| return fmt.Errorf("Wrong Block.Header.LastResultsHash. Expected %X, got %v", s.LastResultsHash, b.LastResultsHash) | |||
| } | |||
| if !bytes.Equal(b.ValidatorsHash, s.Validators.Hash()) { | |||
| return fmt.Errorf("Wrong Block.Header.ValidatorsHash. Expected %X, got %v", s.Validators.Hash(), b.ValidatorsHash) | |||
| } | |||
| // Validate block LastCommit. | |||
| if b.Height == 1 { | |||
| if len(b.LastCommit.Precommits) != 0 { | |||
| return errors.New("Block at height 1 (first block) should have no LastCommit precommits") | |||
| } | |||
| } else { | |||
| if len(b.LastCommit.Precommits) != s.LastValidators.Size() { | |||
| return fmt.Errorf("Invalid block commit size. Expected %v, got %v", | |||
| s.LastValidators.Size(), len(b.LastCommit.Precommits)) | |||
| } | |||
| err := s.LastValidators.VerifyCommit( | |||
| s.ChainID, s.LastBlockID, b.Height-1, b.LastCommit) | |||
| if err != nil { | |||
| return err | |||
| } | |||
| } | |||
| for _, ev := range b.Evidence.Evidence { | |||
| if err := VerifyEvidence(stateDB, s, ev); err != nil { | |||
| return types.NewEvidenceInvalidErr(ev, err) | |||
| } | |||
| } | |||
| return nil | |||
| } | |||
| // XXX: What's cheaper (ie. what should be checked first): | |||
| // evidence internal validity (ie. sig checks) or validator existed (fetch historical val set from db) | |||
| // VerifyEvidence verifies the evidence fully by checking it is internally | |||
| // consistent and sufficiently recent. | |||
| func VerifyEvidence(stateDB dbm.DB, s State, evidence types.Evidence) error { | |||
| height := s.LastBlockHeight | |||
| evidenceAge := height - evidence.Height() | |||
| maxAge := s.ConsensusParams.EvidenceParams.MaxAge | |||
| if evidenceAge > maxAge { | |||
| return fmt.Errorf("Evidence from height %d is too old. Min height is %d", | |||
| evidence.Height(), height-maxAge) | |||
| } | |||
| if err := evidence.Verify(s.ChainID); err != nil { | |||
| return err | |||
| } | |||
| valset, err := LoadValidators(stateDB, evidence.Height()) | |||
| if err != nil { | |||
| // TODO: if err is just that we cant find it cuz we pruned, ignore. | |||
| // TODO: if its actually bad evidence, punish peer | |||
| return err | |||
| } | |||
| // The address must have been an active validator at the height | |||
| ev := evidence | |||
| height, addr, idx := ev.Height(), ev.Address(), ev.Index() | |||
| valIdx, val := valset.GetByAddress(addr) | |||
| if val == nil { | |||
| return fmt.Errorf("Address %X was not a validator at height %d", addr, height) | |||
| } else if idx != valIdx { | |||
| return fmt.Errorf("Address %X was validator %d at height %d, not %d", addr, valIdx, height, idx) | |||
| } | |||
| return nil | |||
| } | |||
+ 68
- 0
state/validation_test.go
View File
| @ -0,0 +1,68 @@ | |||
| package state | |||
| import ( | |||
| "testing" | |||
| "github.com/stretchr/testify/require" | |||
| dbm "github.com/tendermint/tmlibs/db" | |||
| "github.com/tendermint/tmlibs/log" | |||
| ) | |||
| func TestValidateBlock(t *testing.T) { | |||
| state := state() | |||
| blockExec := NewBlockExecutor(dbm.NewMemDB(), log.TestingLogger(), nil, nil, nil) | |||
| // proper block must pass | |||
| block := makeBlock(state, 1) | |||
| err := blockExec.ValidateBlock(state, block) | |||
| require.NoError(t, err) | |||
| // wrong chain fails | |||
| block = makeBlock(state, 1) | |||
| block.ChainID = "not-the-real-one" | |||
| err = blockExec.ValidateBlock(state, block) | |||
| require.Error(t, err) | |||
| // wrong height fails | |||
| block = makeBlock(state, 1) | |||
| block.Height += 10 | |||
| err = blockExec.ValidateBlock(state, block) | |||
| require.Error(t, err) | |||
| // wrong total tx fails | |||
| block = makeBlock(state, 1) | |||
| block.TotalTxs += 10 | |||
| err = blockExec.ValidateBlock(state, block) | |||
| require.Error(t, err) | |||
| // wrong blockid fails | |||
| block = makeBlock(state, 1) | |||
| block.LastBlockID.PartsHeader.Total += 10 | |||
| err = blockExec.ValidateBlock(state, block) | |||
| require.Error(t, err) | |||
| // wrong app hash fails | |||
| block = makeBlock(state, 1) | |||
| block.AppHash = []byte("wrong app hash") | |||
| err = blockExec.ValidateBlock(state, block) | |||
| require.Error(t, err) | |||
| // wrong consensus hash fails | |||
| block = makeBlock(state, 1) | |||
| block.ConsensusHash = []byte("wrong consensus hash") | |||
| err = blockExec.ValidateBlock(state, block) | |||
| require.Error(t, err) | |||
| // wrong results hash fails | |||
| block = makeBlock(state, 1) | |||
| block.LastResultsHash = []byte("wrong results hash") | |||
| err = blockExec.ValidateBlock(state, block) | |||
| require.Error(t, err) | |||
| // wrong validators hash fails | |||
| block = makeBlock(state, 1) | |||
| block.ValidatorsHash = []byte("wrong validators hash") | |||
| err = blockExec.ValidateBlock(state, block) | |||
| require.Error(t, err) | |||
| } | |||