From dd62f06994399e3386c411cc50af224755e68e47 Mon Sep 17 00:00:00 2001 From: Ethan Buchman Date: Mon, 4 Jun 2018 13:31:57 -0700 Subject: [PATCH] state: s -> state --- state/execution.go | 46 ++++++++++++++++----------------- state/state.go | 62 ++++++++++++++++++++++----------------------- state/store.go | 14 +++++----- state/validation.go | 52 ++++++++++++++++++------------------- 4 files changed, 87 insertions(+), 87 deletions(-) diff --git a/state/execution.go b/state/execution.go index 81d157f1d..e5904ecfc 100644 --- a/state/execution.go +++ b/state/execution.go @@ -59,8 +59,8 @@ func (blockExec *BlockExecutor) SetEventBus(eventBus types.BlockEventPublisher) // If the block is invalid, it returns an error. // Validation does not mutate state, but does require historical information from the stateDB, // ie. to verify evidence from a validator at an old height. -func (blockExec *BlockExecutor) ValidateBlock(s State, block *types.Block) error { - return validateBlock(blockExec.db, s, block) +func (blockExec *BlockExecutor) ValidateBlock(state State, block *types.Block) error { + return validateBlock(blockExec.db, state, block) } // ApplyBlock validates the block against the state, executes it against the app, @@ -68,15 +68,15 @@ func (blockExec *BlockExecutor) ValidateBlock(s State, block *types.Block) error // It's the only function that needs to be called // from outside this package to process and commit an entire block. // It takes a blockID to avoid recomputing the parts hash. -func (blockExec *BlockExecutor) ApplyBlock(s State, blockID types.BlockID, block *types.Block) (State, error) { +func (blockExec *BlockExecutor) ApplyBlock(state State, blockID types.BlockID, block *types.Block) (State, error) { - if err := blockExec.ValidateBlock(s, block); err != nil { - return s, ErrInvalidBlock(err) + if err := blockExec.ValidateBlock(state, block); err != nil { + return state, ErrInvalidBlock(err) } abciResponses, err := execBlockOnProxyApp(blockExec.logger, blockExec.proxyApp, block) if err != nil { - return s, ErrProxyAppConn(err) + return state, ErrProxyAppConn(err) } fail.Fail() // XXX @@ -87,22 +87,22 @@ func (blockExec *BlockExecutor) ApplyBlock(s State, blockID types.BlockID, block fail.Fail() // XXX // update the state with the block and responses - s, err = updateState(s, blockID, block.Header, abciResponses) + state, err = updateState(state, blockID, block.Header, abciResponses) if err != nil { - return s, fmt.Errorf("Commit failed for application: %v", err) + return state, fmt.Errorf("Commit failed for application: %v", err) } // lock mempool, commit state, update mempoool appHash, err := blockExec.Commit(block) if err != nil { - return s, fmt.Errorf("Commit failed for application: %v", err) + return state, fmt.Errorf("Commit failed for application: %v", err) } fail.Fail() // XXX // update the app hash and save the state - s.AppHash = appHash - SaveState(blockExec.db, s) + state.AppHash = appHash + SaveState(blockExec.db, state) fail.Fail() // XXX @@ -115,7 +115,7 @@ func (blockExec *BlockExecutor) ApplyBlock(s State, blockID types.BlockID, block // NOTE: if we crash between Commit and Save, events wont be fired during replay fireEvents(blockExec.logger, blockExec.eventBus, block, abciResponses) - return s, nil + return state, nil } // Commit locks the mempool, runs the ABCI Commit message, and updates the mempool. @@ -283,20 +283,20 @@ func updateValidators(currentSet *types.ValidatorSet, updates []abci.Validator) } // updateState returns a new State updated according to the header and responses. -func updateState(s State, blockID types.BlockID, header *types.Header, +func updateState(state State, blockID types.BlockID, header *types.Header, abciResponses *ABCIResponses) (State, error) { // copy the valset so we can apply changes from EndBlock // and update s.LastValidators and s.Validators - prevValSet := s.Validators.Copy() + prevValSet := state.Validators.Copy() nextValSet := prevValSet.Copy() // update the validator set with the latest abciResponses - lastHeightValsChanged := s.LastHeightValidatorsChanged + lastHeightValsChanged := state.LastHeightValidatorsChanged if len(abciResponses.EndBlock.ValidatorUpdates) > 0 { err := updateValidators(nextValSet, abciResponses.EndBlock.ValidatorUpdates) if err != nil { - return s, fmt.Errorf("Error changing validator set: %v", err) + return state, fmt.Errorf("Error changing validator set: %v", err) } // change results from this height but only applies to the next height lastHeightValsChanged = header.Height + 1 @@ -306,14 +306,14 @@ func updateState(s State, blockID types.BlockID, header *types.Header, nextValSet.IncrementAccum(1) // update the params with the latest abciResponses - nextParams := s.ConsensusParams - lastHeightParamsChanged := s.LastHeightConsensusParamsChanged + nextParams := state.ConsensusParams + lastHeightParamsChanged := state.LastHeightConsensusParamsChanged if abciResponses.EndBlock.ConsensusParamUpdates != nil { // NOTE: must not mutate s.ConsensusParams - nextParams = s.ConsensusParams.Update(abciResponses.EndBlock.ConsensusParamUpdates) + nextParams = state.ConsensusParams.Update(abciResponses.EndBlock.ConsensusParamUpdates) err := nextParams.Validate() if err != nil { - return s, fmt.Errorf("Error updating consensus params: %v", err) + return state, fmt.Errorf("Error updating consensus params: %v", err) } // change results from this height but only applies to the next height lastHeightParamsChanged = header.Height + 1 @@ -322,13 +322,13 @@ func updateState(s State, blockID types.BlockID, header *types.Header, // NOTE: the AppHash has not been populated. // It will be filled on state.Save. return State{ - ChainID: s.ChainID, + ChainID: state.ChainID, LastBlockHeight: header.Height, - LastBlockTotalTx: s.LastBlockTotalTx + header.NumTxs, + LastBlockTotalTx: state.LastBlockTotalTx + header.NumTxs, LastBlockID: blockID, LastBlockTime: header.Time, Validators: nextValSet, - LastValidators: s.Validators.Copy(), + LastValidators: state.Validators.Copy(), LastHeightValidatorsChanged: lastHeightValsChanged, ConsensusParams: nextParams, LastHeightConsensusParamsChanged: lastHeightParamsChanged, diff --git a/state/state.go b/state/state.go index aa6e04b66..3bc08dae3 100644 --- a/state/state.go +++ b/state/state.go @@ -55,67 +55,67 @@ type State struct { } // Copy makes a copy of the State for mutating. -func (s State) Copy() State { +func (state State) Copy() State { return State{ - ChainID: s.ChainID, + ChainID: state.ChainID, - LastBlockHeight: s.LastBlockHeight, - LastBlockTotalTx: s.LastBlockTotalTx, - LastBlockID: s.LastBlockID, - LastBlockTime: s.LastBlockTime, + LastBlockHeight: state.LastBlockHeight, + LastBlockTotalTx: state.LastBlockTotalTx, + LastBlockID: state.LastBlockID, + LastBlockTime: state.LastBlockTime, - Validators: s.Validators.Copy(), - LastValidators: s.LastValidators.Copy(), - LastHeightValidatorsChanged: s.LastHeightValidatorsChanged, + Validators: state.Validators.Copy(), + LastValidators: state.LastValidators.Copy(), + LastHeightValidatorsChanged: state.LastHeightValidatorsChanged, - ConsensusParams: s.ConsensusParams, - LastHeightConsensusParamsChanged: s.LastHeightConsensusParamsChanged, + ConsensusParams: state.ConsensusParams, + LastHeightConsensusParamsChanged: state.LastHeightConsensusParamsChanged, - AppHash: s.AppHash, + AppHash: state.AppHash, - LastResultsHash: s.LastResultsHash, + LastResultsHash: state.LastResultsHash, } } // Equals returns true if the States are identical. -func (s State) Equals(s2 State) bool { - sbz, s2bz := s.Bytes(), s2.Bytes() +func (state State) Equals(state2 State) bool { + sbz, s2bz := state.Bytes(), state2.Bytes() return bytes.Equal(sbz, s2bz) } // Bytes serializes the State using go-amino. -func (s State) Bytes() []byte { - return cdc.MustMarshalBinaryBare(s) +func (state State) Bytes() []byte { + return cdc.MustMarshalBinaryBare(state) } // IsEmpty returns true if the State is equal to the empty State. -func (s State) IsEmpty() bool { - return s.Validators == nil // XXX can't compare to Empty +func (state State) IsEmpty() bool { + return state.Validators == nil // XXX can't compare to Empty } // GetValidators returns the last and current validator sets. -func (s State) GetValidators() (last *types.ValidatorSet, current *types.ValidatorSet) { - return s.LastValidators, s.Validators +func (state State) GetValidators() (last *types.ValidatorSet, current *types.ValidatorSet) { + return state.LastValidators, state.Validators } //------------------------------------------------------------------------ // Create a block from the latest state // MakeBlock builds a block with the given txs and commit from the current state. -func (s State) MakeBlock(height int64, txs []types.Tx, commit *types.Commit) (*types.Block, *types.PartSet) { +func (state State) MakeBlock(height int64, txs []types.Tx, commit *types.Commit) (*types.Block, *types.PartSet) { // build base block block := types.MakeBlock(height, txs, commit) // fill header with state data - block.ChainID = s.ChainID - block.TotalTxs = s.LastBlockTotalTx + block.NumTxs - block.LastBlockID = s.LastBlockID - block.ValidatorsHash = s.Validators.Hash() - block.AppHash = s.AppHash - block.ConsensusHash = s.ConsensusParams.Hash() - block.LastResultsHash = s.LastResultsHash - - return block, block.MakePartSet(s.ConsensusParams.BlockGossip.BlockPartSizeBytes) + block.ChainID = state.ChainID + block.TotalTxs = state.LastBlockTotalTx + block.NumTxs + block.LastBlockID = state.LastBlockID + block.ValidatorsHash = state.Validators.Hash() + block.AppHash = state.AppHash + block.ConsensusHash = state.ConsensusParams.Hash() + block.LastResultsHash = state.LastResultsHash + + return block, block.MakePartSet(state.ConsensusParams.BlockGossip.BlockPartSizeBytes) } //------------------------------------------------------------------------ diff --git a/state/store.go b/state/store.go index ee0619d34..60acf9e1e 100644 --- a/state/store.go +++ b/state/store.go @@ -80,15 +80,15 @@ func loadState(db dbm.DB, key []byte) (state 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, state State) { + saveState(db, state, 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()) +func saveState(db dbm.DB, state State, key []byte) { + nextHeight := state.LastBlockHeight + 1 + saveValidatorsInfo(db, nextHeight, state.LastHeightValidatorsChanged, state.Validators) + saveConsensusParamsInfo(db, nextHeight, state.LastHeightConsensusParamsChanged, state.ConsensusParams) + db.SetSync(stateKey, state.Bytes()) } //------------------------------------------------------------------------ diff --git a/state/validation.go b/state/validation.go index fb3e8d13d..6f4f383d2 100644 --- a/state/validation.go +++ b/state/validation.go @@ -12,18 +12,18 @@ import ( //----------------------------------------------------- // Validate block -func validateBlock(stateDB dbm.DB, s State, b *types.Block) error { +func validateBlock(stateDB dbm.DB, state 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.ChainID != state.ChainID { + return fmt.Errorf("Wrong Block.Header.ChainID. Expected %v, got %v", state.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) + if b.Height != state.LastBlockHeight+1 { + return fmt.Errorf("Wrong Block.Header.Height. Expected %v, got %v", state.LastBlockHeight+1, b.Height) } /* TODO: Determine bounds for Time See blockchain/reactor "stopSyncingDurationMinutes" @@ -34,26 +34,26 @@ func validateBlock(stateDB dbm.DB, s State, b *types.Block) error { */ // 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) + if !b.LastBlockID.Equals(state.LastBlockID) { + return fmt.Errorf("Wrong Block.Header.LastBlockID. Expected %v, got %v", state.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) + if b.TotalTxs != state.LastBlockTotalTx+newTxs { + return fmt.Errorf("Wrong Block.Header.TotalTxs. Expected %v, got %v", state.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.AppHash, state.AppHash) { + return fmt.Errorf("Wrong Block.Header.AppHash. Expected %X, got %v", state.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.ConsensusHash, state.ConsensusParams.Hash()) { + return fmt.Errorf("Wrong Block.Header.ConsensusHash. Expected %X, got %v", state.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.LastResultsHash, state.LastResultsHash) { + return fmt.Errorf("Wrong Block.Header.LastResultsHash. Expected %X, got %v", state.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) + if !bytes.Equal(b.ValidatorsHash, state.Validators.Hash()) { + return fmt.Errorf("Wrong Block.Header.ValidatorsHash. Expected %X, got %v", state.Validators.Hash(), b.ValidatorsHash) } // Validate block LastCommit. @@ -62,19 +62,19 @@ func validateBlock(stateDB dbm.DB, s State, b *types.Block) error { return errors.New("Block at height 1 (first block) should have no LastCommit precommits") } } else { - if len(b.LastCommit.Precommits) != s.LastValidators.Size() { + if len(b.LastCommit.Precommits) != state.LastValidators.Size() { return fmt.Errorf("Invalid block commit size. Expected %v, got %v", - s.LastValidators.Size(), len(b.LastCommit.Precommits)) + state.LastValidators.Size(), len(b.LastCommit.Precommits)) } - err := s.LastValidators.VerifyCommit( - s.ChainID, s.LastBlockID, b.Height-1, b.LastCommit) + err := state.LastValidators.VerifyCommit( + state.ChainID, state.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 { + if err := VerifyEvidence(stateDB, state, ev); err != nil { return types.NewEvidenceInvalidErr(ev, err) } } @@ -87,17 +87,17 @@ func validateBlock(stateDB dbm.DB, s State, b *types.Block) error { // 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 +func VerifyEvidence(stateDB dbm.DB, state State, evidence types.Evidence) error { + height := state.LastBlockHeight evidenceAge := height - evidence.Height() - maxAge := s.ConsensusParams.EvidenceParams.MaxAge + maxAge := state.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 { + if err := evidence.Verify(state.ChainID); err != nil { return err }