2015-03-28 23:44:07 -07:00
|
|
|
package state
|
|
|
|
|
|
|
|
import (
|
2017-02-17 16:12:05 -08:00
|
|
|
"bytes"
|
2015-03-28 23:44:07 -07:00
|
|
|
"errors"
|
|
|
|
|
2016-09-11 12:32:33 -07:00
|
|
|
"github.com/ebuchman/fail-test"
|
|
|
|
|
2017-02-14 12:33:14 -08:00
|
|
|
abci "github.com/tendermint/abci/types"
|
2015-10-22 17:39:06 -07:00
|
|
|
. "github.com/tendermint/go-common"
|
2016-11-16 13:13:17 -08:00
|
|
|
cfg "github.com/tendermint/go-config"
|
2016-11-19 16:32:35 -08:00
|
|
|
"github.com/tendermint/go-crypto"
|
2015-12-01 20:12:01 -08:00
|
|
|
"github.com/tendermint/tendermint/proxy"
|
2015-04-01 17:30:16 -07:00
|
|
|
"github.com/tendermint/tendermint/types"
|
2015-03-28 23:44:07 -07:00
|
|
|
)
|
|
|
|
|
2016-09-11 10:16:23 -07:00
|
|
|
//--------------------------------------------------
|
|
|
|
// Execute the block
|
|
|
|
|
2015-12-01 20:12:01 -08:00
|
|
|
// Execute the block to mutate State.
|
2016-01-06 17:14:20 -08:00
|
|
|
// Validates block and then executes Data.Txs in the block.
|
2016-10-09 23:58:13 -07:00
|
|
|
func (s *State) ExecBlock(eventCache types.Fireable, proxyAppConn proxy.AppConnConsensus, block *types.Block, blockPartsHeader types.PartSetHeader) error {
|
2015-12-01 20:12:01 -08:00
|
|
|
|
|
|
|
// Validate the block.
|
2016-11-19 16:32:35 -08:00
|
|
|
if err := s.validateBlock(block); err != nil {
|
2016-09-11 10:16:23 -07:00
|
|
|
return ErrInvalidBlock(err)
|
2015-03-28 23:44:07 -07:00
|
|
|
}
|
2015-12-01 20:12:01 -08:00
|
|
|
|
2016-11-19 16:32:35 -08:00
|
|
|
// compute bitarray of validators that signed
|
2016-11-16 17:58:53 -08:00
|
|
|
signed := commitBitArrayFromBlock(block)
|
2016-11-19 16:32:35 -08:00
|
|
|
_ = signed // TODO send on begin block
|
2016-11-16 17:58:53 -08:00
|
|
|
|
2016-11-19 16:32:35 -08:00
|
|
|
// copy the valset
|
|
|
|
valSet := s.Validators.Copy()
|
2015-12-01 20:12:01 -08:00
|
|
|
nextValSet := valSet.Copy()
|
|
|
|
|
2016-01-06 17:14:20 -08:00
|
|
|
// Execute the block txs
|
2016-11-19 16:32:35 -08:00
|
|
|
changedValidators, err := execBlockOnProxyApp(eventCache, proxyAppConn, block)
|
2015-12-01 20:12:01 -08:00
|
|
|
if err != nil {
|
2016-01-06 17:14:20 -08:00
|
|
|
// There was some error in proxyApp
|
|
|
|
// TODO Report error and wait for proxyApp to be available.
|
2016-09-11 10:16:23 -07:00
|
|
|
return ErrProxyAppConn(err)
|
2015-12-01 20:12:01 -08:00
|
|
|
}
|
|
|
|
|
2016-11-19 16:32:35 -08:00
|
|
|
// update the validator set
|
2016-12-01 21:12:06 -08:00
|
|
|
err = updateValidators(nextValSet, changedValidators)
|
2016-11-19 17:29:07 -08:00
|
|
|
if err != nil {
|
2016-11-19 16:32:35 -08:00
|
|
|
log.Warn("Error changing validator set", "error", err)
|
|
|
|
// TODO: err or carry on?
|
|
|
|
}
|
|
|
|
|
2015-12-01 20:12:01 -08:00
|
|
|
// All good!
|
2016-08-23 18:44:07 -07:00
|
|
|
// Update validator accums and set state variables
|
2015-12-01 20:12:01 -08:00
|
|
|
nextValSet.IncrementAccum(1)
|
2016-08-23 18:44:07 -07:00
|
|
|
s.SetBlockAndValidators(block.Header, blockPartsHeader, valSet, nextValSet)
|
2015-12-01 20:12:01 -08:00
|
|
|
|
2016-12-22 12:01:22 -08:00
|
|
|
fail.Fail() // XXX
|
2016-09-11 10:16:23 -07:00
|
|
|
|
2015-03-28 23:44:07 -07:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2016-01-06 17:14:20 -08:00
|
|
|
// Executes block's transactions on proxyAppConn.
|
2016-11-19 16:32:35 -08:00
|
|
|
// Returns a list of updates to the validator set
|
2016-01-06 17:14:20 -08:00
|
|
|
// TODO: Generate a bitmap or otherwise store tx validity in state.
|
2017-01-12 12:53:32 -08:00
|
|
|
func execBlockOnProxyApp(eventCache types.Fireable, proxyAppConn proxy.AppConnConsensus, block *types.Block) ([]*abci.Validator, error) {
|
2016-06-27 17:43:09 -07:00
|
|
|
|
2016-01-06 17:14:20 -08:00
|
|
|
var validTxs, invalidTxs = 0, 0
|
2015-12-01 20:12:01 -08:00
|
|
|
|
|
|
|
// Execute transactions and get hash
|
2017-01-12 12:53:32 -08:00
|
|
|
proxyCb := func(req *abci.Request, res *abci.Response) {
|
2016-05-14 09:33:27 -07:00
|
|
|
switch r := res.Value.(type) {
|
2017-01-12 12:55:03 -08:00
|
|
|
case *abci.Response_DeliverTx:
|
2016-01-25 14:34:08 -08:00
|
|
|
// TODO: make use of res.Log
|
2016-01-06 17:14:20 -08:00
|
|
|
// TODO: make use of this info
|
|
|
|
// Blocks may include invalid txs.
|
2017-01-12 12:55:03 -08:00
|
|
|
// reqDeliverTx := req.(abci.RequestDeliverTx)
|
2016-10-01 13:12:48 -07:00
|
|
|
txError := ""
|
2017-01-12 12:55:03 -08:00
|
|
|
apTx := r.DeliverTx
|
2017-01-12 12:53:32 -08:00
|
|
|
if apTx.Code == abci.CodeType_OK {
|
2016-01-06 17:14:20 -08:00
|
|
|
validTxs += 1
|
|
|
|
} else {
|
2017-01-12 12:55:03 -08:00
|
|
|
log.Debug("Invalid tx", "code", r.DeliverTx.Code, "log", r.DeliverTx.Log)
|
2016-01-06 17:14:20 -08:00
|
|
|
invalidTxs += 1
|
2016-10-09 23:58:13 -07:00
|
|
|
txError = apTx.Code.String()
|
2015-12-01 20:12:01 -08:00
|
|
|
}
|
2016-06-27 17:43:09 -07:00
|
|
|
// NOTE: if we count we can access the tx from the block instead of
|
|
|
|
// pulling it from the req
|
2016-10-01 13:12:48 -07:00
|
|
|
event := types.EventDataTx{
|
2017-01-12 12:55:03 -08:00
|
|
|
Tx: req.GetDeliverTx().Tx,
|
2016-11-30 14:28:41 -08:00
|
|
|
Data: apTx.Data,
|
|
|
|
Code: apTx.Code,
|
|
|
|
Log: apTx.Log,
|
|
|
|
Error: txError,
|
2016-10-01 13:12:48 -07:00
|
|
|
}
|
2016-10-09 23:58:13 -07:00
|
|
|
types.FireEventTx(eventCache, event)
|
2015-12-01 20:12:01 -08:00
|
|
|
}
|
|
|
|
}
|
2016-01-06 17:14:20 -08:00
|
|
|
proxyAppConn.SetResponseCallback(proxyCb)
|
|
|
|
|
2016-11-03 16:51:22 -07:00
|
|
|
// Begin block
|
2016-09-10 20:35:18 -07:00
|
|
|
err := proxyAppConn.BeginBlockSync(block.Hash(), types.TM2PB.Header(block.Header))
|
2016-11-03 16:51:22 -07:00
|
|
|
if err != nil {
|
|
|
|
log.Warn("Error in proxyAppConn.BeginBlock", "error", err)
|
2016-11-19 16:32:35 -08:00
|
|
|
return nil, err
|
2016-11-03 16:51:22 -07:00
|
|
|
}
|
2016-08-06 20:30:46 -07:00
|
|
|
|
2016-09-11 12:32:33 -07:00
|
|
|
fail.Fail() // XXX
|
|
|
|
|
2016-03-05 20:57:36 -08:00
|
|
|
// Run txs of block
|
2016-01-06 17:14:20 -08:00
|
|
|
for _, tx := range block.Txs {
|
2016-09-11 12:32:33 -07:00
|
|
|
fail.FailRand(len(block.Txs)) // XXX
|
2017-01-12 12:55:03 -08:00
|
|
|
proxyAppConn.DeliverTxAsync(tx)
|
2016-01-06 17:14:20 -08:00
|
|
|
if err := proxyAppConn.Error(); err != nil {
|
2016-11-19 16:32:35 -08:00
|
|
|
return nil, err
|
2015-12-01 20:12:01 -08:00
|
|
|
}
|
|
|
|
}
|
2016-03-05 20:57:36 -08:00
|
|
|
|
2016-09-11 12:32:33 -07:00
|
|
|
fail.Fail() // XXX
|
|
|
|
|
2016-03-05 20:57:36 -08:00
|
|
|
// End block
|
2017-01-12 12:13:47 -08:00
|
|
|
respEndBlock, err := proxyAppConn.EndBlockSync(uint64(block.Height))
|
2016-03-05 20:57:36 -08:00
|
|
|
if err != nil {
|
|
|
|
log.Warn("Error in proxyAppConn.EndBlock", "error", err)
|
2016-11-19 16:32:35 -08:00
|
|
|
return nil, err
|
2016-03-05 20:57:36 -08:00
|
|
|
}
|
2016-09-11 12:32:33 -07:00
|
|
|
|
|
|
|
fail.Fail() // XXX
|
|
|
|
|
2016-11-22 15:55:42 -08:00
|
|
|
log.Info("Executed block", "height", block.Height, "valid txs", validTxs, "invalid txs", invalidTxs)
|
2017-01-12 12:13:47 -08:00
|
|
|
if len(respEndBlock.Diffs) > 0 {
|
2017-01-12 12:53:32 -08:00
|
|
|
log.Info("Update to validator set", "updates", abci.ValidatorsString(respEndBlock.Diffs))
|
2016-11-22 15:55:42 -08:00
|
|
|
}
|
2017-01-12 12:13:47 -08:00
|
|
|
return respEndBlock.Diffs, nil
|
2016-11-19 16:32:35 -08:00
|
|
|
}
|
|
|
|
|
2017-01-12 12:53:32 -08:00
|
|
|
func updateValidators(validators *types.ValidatorSet, changedValidators []*abci.Validator) error {
|
2016-11-19 16:32:35 -08:00
|
|
|
// TODO: prevent change of 1/3+ at once
|
|
|
|
|
|
|
|
for _, v := range changedValidators {
|
|
|
|
pubkey, err := crypto.PubKeyFromBytes(v.PubKey) // NOTE: expects go-wire encoded pubkey
|
|
|
|
if err != nil {
|
2016-12-01 21:12:06 -08:00
|
|
|
return err
|
2016-11-19 16:32:35 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
address := pubkey.Address()
|
|
|
|
power := int64(v.Power)
|
|
|
|
// mind the overflow from uint64
|
|
|
|
if power < 0 {
|
2016-12-01 21:12:06 -08:00
|
|
|
return errors.New(Fmt("Power (%d) overflows int64", v.Power))
|
2016-11-19 16:32:35 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
_, val := validators.GetByAddress(address)
|
|
|
|
if val == nil {
|
|
|
|
// add val
|
|
|
|
added := validators.Add(types.NewValidator(pubkey, power))
|
|
|
|
if !added {
|
2016-12-01 21:12:06 -08:00
|
|
|
return errors.New(Fmt("Failed to add new validator %X with voting power %d", address, power))
|
2016-11-19 16:32:35 -08:00
|
|
|
}
|
|
|
|
} else if v.Power == 0 {
|
|
|
|
// remove val
|
|
|
|
_, removed := validators.Remove(address)
|
|
|
|
if !removed {
|
2016-12-01 21:12:06 -08:00
|
|
|
return errors.New(Fmt("Failed to remove validator %X)"))
|
2016-11-19 16:32:35 -08:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// update val
|
|
|
|
val.VotingPower = power
|
|
|
|
updated := validators.Update(val)
|
|
|
|
if !updated {
|
2016-12-01 21:12:06 -08:00
|
|
|
return errors.New(Fmt("Failed to update validator %X with voting power %d", address, power))
|
2016-11-19 16:32:35 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-12-01 21:12:06 -08:00
|
|
|
return nil
|
2015-12-01 20:12:01 -08:00
|
|
|
}
|
|
|
|
|
2016-11-16 17:58:53 -08:00
|
|
|
// return a bit array of validators that signed the last commit
|
|
|
|
// NOTE: assumes commits have already been authenticated
|
|
|
|
func commitBitArrayFromBlock(block *types.Block) *BitArray {
|
|
|
|
signed := NewBitArray(len(block.LastCommit.Precommits))
|
2016-04-02 09:10:16 -07:00
|
|
|
for i, precommit := range block.LastCommit.Precommits {
|
2016-11-22 15:55:42 -08:00
|
|
|
if precommit != nil {
|
|
|
|
signed.SetIndex(i, true) // val_.LastCommitHeight = block.Height - 1
|
2015-03-28 23:44:07 -07:00
|
|
|
}
|
|
|
|
}
|
2016-11-16 17:58:53 -08:00
|
|
|
return signed
|
2015-05-12 17:40:19 -07:00
|
|
|
}
|
2015-08-10 20:38:45 -07:00
|
|
|
|
2016-09-11 10:16:23 -07:00
|
|
|
//-----------------------------------------------------
|
|
|
|
// Validate block
|
2015-08-10 20:38:45 -07:00
|
|
|
|
2016-09-11 10:16:23 -07:00
|
|
|
func (s *State) ValidateBlock(block *types.Block) error {
|
|
|
|
return s.validateBlock(block)
|
2015-08-10 20:38:45 -07:00
|
|
|
}
|
|
|
|
|
2016-09-11 10:16:23 -07:00
|
|
|
func (s *State) validateBlock(block *types.Block) error {
|
|
|
|
// Basic block validation.
|
|
|
|
err := block.ValidateBasic(s.ChainID, s.LastBlockHeight, s.LastBlockID, s.LastBlockTime, s.AppHash)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
// Validate block LastCommit.
|
|
|
|
if block.Height == 1 {
|
|
|
|
if len(block.LastCommit.Precommits) != 0 {
|
|
|
|
return errors.New("Block at height 1 (first block) should have no LastCommit precommits")
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if len(block.LastCommit.Precommits) != s.LastValidators.Size() {
|
|
|
|
return errors.New(Fmt("Invalid block commit size. Expected %v, got %v",
|
|
|
|
s.LastValidators.Size(), len(block.LastCommit.Precommits)))
|
|
|
|
}
|
|
|
|
err := s.LastValidators.VerifyCommit(
|
|
|
|
s.ChainID, s.LastBlockID, block.Height-1, block.LastCommit)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
2015-12-01 20:12:01 -08:00
|
|
|
}
|
2016-08-23 18:44:07 -07:00
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
2016-09-11 10:16:23 -07:00
|
|
|
// ApplyBlock executes the block, then commits and updates the mempool atomically
|
|
|
|
|
|
|
|
// Execute and commit block against app, save block and state
|
2016-11-03 17:38:09 -07:00
|
|
|
func (s *State) ApplyBlock(eventCache types.Fireable, proxyAppConn proxy.AppConnConsensus,
|
2016-09-11 10:16:23 -07:00
|
|
|
block *types.Block, partsHeader types.PartSetHeader, mempool Mempool) error {
|
|
|
|
|
|
|
|
// Run the block on the State:
|
|
|
|
// + update validator sets
|
|
|
|
// + run txs on the proxyAppConn
|
|
|
|
err := s.ExecBlock(eventCache, proxyAppConn, block, partsHeader)
|
|
|
|
if err != nil {
|
|
|
|
return errors.New(Fmt("Exec failed for application: %v", err))
|
|
|
|
}
|
|
|
|
|
|
|
|
// lock mempool, commit state, update mempoool
|
|
|
|
err = s.CommitStateUpdateMempool(proxyAppConn, block, mempool)
|
|
|
|
if err != nil {
|
|
|
|
return errors.New(Fmt("Commit failed for application: %v", err))
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
2016-08-23 18:44:07 -07:00
|
|
|
|
2016-08-24 21:18:03 -07:00
|
|
|
// mempool must be locked during commit and update
|
|
|
|
// because state is typically reset on Commit and old txs must be replayed
|
|
|
|
// against committed state before new txs are run in the mempool, lest they be invalid
|
|
|
|
func (s *State) CommitStateUpdateMempool(proxyAppConn proxy.AppConnConsensus, block *types.Block, mempool Mempool) error {
|
|
|
|
mempool.Lock()
|
|
|
|
defer mempool.Unlock()
|
|
|
|
|
|
|
|
// Commit block, get hash back
|
|
|
|
res := proxyAppConn.CommitSync()
|
|
|
|
if res.IsErr() {
|
|
|
|
log.Warn("Error in proxyAppConn.CommitSync", "error", res)
|
|
|
|
return res
|
|
|
|
}
|
|
|
|
if res.Log != "" {
|
|
|
|
log.Debug("Commit.Log: " + res.Log)
|
|
|
|
}
|
|
|
|
|
2017-02-20 13:24:35 -08:00
|
|
|
log.Info("Committed state", "hash", res.Data)
|
2016-08-24 21:18:03 -07:00
|
|
|
// Set the state's new AppHash
|
|
|
|
s.AppHash = res.Data
|
|
|
|
|
|
|
|
// Update mempool.
|
|
|
|
mempool.Update(block.Height, block.Txs)
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-18 19:15:59 -08:00
|
|
|
// Apply and commit a block, but without all the state validation.
|
|
|
|
// Returns the application root hash (result of abci.Commit)
|
2017-02-17 08:32:56 -08:00
|
|
|
func applyBlock(appConnConsensus proxy.AppConnConsensus, block *types.Block) ([]byte, error) {
|
|
|
|
var eventCache types.Fireable // nil
|
|
|
|
_, err := execBlockOnProxyApp(eventCache, appConnConsensus, block)
|
|
|
|
if err != nil {
|
2017-02-17 16:12:05 -08:00
|
|
|
log.Warn("Error executing block on proxy app", "height", block.Height, "err", err)
|
2017-02-17 08:32:56 -08:00
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
// Commit block, get hash back
|
|
|
|
res := appConnConsensus.CommitSync()
|
|
|
|
if res.IsErr() {
|
|
|
|
log.Warn("Error in proxyAppConn.CommitSync", "error", res)
|
|
|
|
return nil, res
|
|
|
|
}
|
|
|
|
if res.Log != "" {
|
|
|
|
log.Info("Commit.Log: " + res.Log)
|
|
|
|
}
|
|
|
|
return res.Data, nil
|
|
|
|
}
|
|
|
|
|
2016-09-11 10:16:23 -07:00
|
|
|
// Updates to the mempool need to be synchronized with committing a block
|
|
|
|
// so apps can reset their transient state on Commit
|
|
|
|
type Mempool interface {
|
|
|
|
Lock()
|
|
|
|
Unlock()
|
2017-02-16 14:56:45 -08:00
|
|
|
|
|
|
|
CheckTx(types.Tx, func(*abci.Response)) error
|
|
|
|
Reap(int) types.Txs
|
|
|
|
Update(height int, txs types.Txs)
|
2016-09-11 10:16:23 -07:00
|
|
|
}
|
2016-08-24 21:18:03 -07:00
|
|
|
|
2016-12-06 20:01:55 -08:00
|
|
|
type MockMempool struct {
|
2016-09-11 10:16:23 -07:00
|
|
|
}
|
2016-08-24 21:18:03 -07:00
|
|
|
|
2017-02-16 14:56:45 -08:00
|
|
|
func (m MockMempool) Lock() {}
|
|
|
|
func (m MockMempool) Unlock() {}
|
|
|
|
func (m MockMempool) CheckTx(tx types.Tx, cb func(*abci.Response)) error { return nil }
|
|
|
|
func (m MockMempool) Reap(n int) types.Txs { return types.Txs{} }
|
|
|
|
func (m MockMempool) Update(height int, txs types.Txs) {}
|
2016-09-11 10:16:23 -07:00
|
|
|
|
|
|
|
//----------------------------------------------------------------
|
2016-11-05 18:48:39 -07:00
|
|
|
// Handshake with app to sync to latest state of core by replaying blocks
|
2016-09-11 10:16:23 -07:00
|
|
|
|
2016-11-05 18:48:39 -07:00
|
|
|
// TODO: Should we move blockchain/store.go to its own package?
|
|
|
|
type BlockStore interface {
|
|
|
|
Height() int
|
2017-02-17 07:51:05 -08:00
|
|
|
|
2016-11-22 15:55:42 -08:00
|
|
|
LoadBlockMeta(height int) *types.BlockMeta
|
2017-02-17 07:51:05 -08:00
|
|
|
LoadBlock(height int) *types.Block
|
|
|
|
LoadBlockPart(height int, index int) *types.Part
|
|
|
|
|
|
|
|
SaveBlock(block *types.Block, blockParts *types.PartSet, seenCommit *types.Commit)
|
|
|
|
|
|
|
|
LoadBlockCommit(height int) *types.Commit
|
|
|
|
LoadSeenCommit(height int) *types.Commit
|
2016-09-11 10:16:23 -07:00
|
|
|
}
|
|
|
|
|
2017-02-20 13:24:35 -08:00
|
|
|
// returns the apphash from Commit
|
|
|
|
type blockReplayFunc func(cfg.Config, *State, proxy.AppConnConsensus, BlockStore) ([]byte, error)
|
2017-02-16 14:56:45 -08:00
|
|
|
|
2016-11-05 18:48:39 -07:00
|
|
|
type Handshaker struct {
|
2017-02-16 14:56:45 -08:00
|
|
|
config cfg.Config
|
|
|
|
state *State
|
|
|
|
store BlockStore
|
|
|
|
replayLastBlock blockReplayFunc
|
2016-09-11 10:16:23 -07:00
|
|
|
|
2016-11-05 18:48:39 -07:00
|
|
|
nBlocks int // number of blocks applied to the state
|
2016-09-11 12:32:33 -07:00
|
|
|
}
|
|
|
|
|
2017-02-16 14:56:45 -08:00
|
|
|
func NewHandshaker(config cfg.Config, state *State, store BlockStore, f blockReplayFunc) *Handshaker {
|
|
|
|
return &Handshaker{config, state, store, f, 0}
|
2016-09-11 12:32:33 -07:00
|
|
|
}
|
|
|
|
|
2017-02-17 07:51:05 -08:00
|
|
|
func (h *Handshaker) NBlocks() int {
|
|
|
|
return h.nBlocks
|
|
|
|
}
|
|
|
|
|
2016-11-22 15:55:42 -08:00
|
|
|
// TODO: retry the handshake/replay if it fails ?
|
2016-11-05 18:48:39 -07:00
|
|
|
func (h *Handshaker) Handshake(proxyApp proxy.AppConns) error {
|
|
|
|
// handshake is done via info request on the query conn
|
2017-01-12 12:13:47 -08:00
|
|
|
res, err := proxyApp.Query().InfoSync()
|
|
|
|
if err != nil {
|
|
|
|
return errors.New(Fmt("Error calling Info: %v", err))
|
2016-11-05 18:48:39 -07:00
|
|
|
}
|
|
|
|
|
2017-01-12 12:13:47 -08:00
|
|
|
blockHeight := int(res.LastBlockHeight) // XXX: beware overflow
|
|
|
|
appHash := res.LastBlockAppHash
|
2016-11-05 18:48:39 -07:00
|
|
|
|
2017-01-12 12:53:32 -08:00
|
|
|
log.Notice("ABCI Handshake", "appHeight", blockHeight, "appHash", appHash)
|
2016-11-05 18:48:39 -07:00
|
|
|
|
2017-01-12 12:13:47 -08:00
|
|
|
// TODO: check version
|
2016-09-11 10:16:23 -07:00
|
|
|
|
2016-11-05 18:48:39 -07:00
|
|
|
// replay blocks up to the latest in the blockstore
|
2017-02-20 14:08:38 -08:00
|
|
|
_, err = h.ReplayBlocks(appHash, blockHeight, proxyApp)
|
2016-11-05 18:48:39 -07:00
|
|
|
if err != nil {
|
|
|
|
return errors.New(Fmt("Error on replay: %v", err))
|
|
|
|
}
|
|
|
|
|
|
|
|
// TODO: (on restart) replay mempool
|
|
|
|
|
|
|
|
return nil
|
2016-08-24 21:18:03 -07:00
|
|
|
}
|
|
|
|
|
2017-02-20 14:08:38 -08:00
|
|
|
// Replay all blocks since appBlockHeight and ensure the result matches the current state.
|
2017-02-20 13:24:35 -08:00
|
|
|
// Returns the final AppHash or an error
|
|
|
|
func (h *Handshaker) ReplayBlocks(appHash []byte, appBlockHeight int, proxyApp proxy.AppConns) ([]byte, error) {
|
2016-08-23 18:44:07 -07:00
|
|
|
|
2016-11-22 15:55:42 -08:00
|
|
|
storeBlockHeight := h.store.Height()
|
2016-12-22 12:01:22 -08:00
|
|
|
stateBlockHeight := h.state.LastBlockHeight
|
2017-01-12 12:53:32 -08:00
|
|
|
log.Notice("ABCI Replay Blocks", "appHeight", appBlockHeight, "storeHeight", storeBlockHeight, "stateHeight", stateBlockHeight)
|
2016-12-22 12:01:22 -08:00
|
|
|
|
2017-02-20 13:24:35 -08:00
|
|
|
// First handle edge cases and constraints on the storeBlockHeight
|
2016-12-22 12:01:22 -08:00
|
|
|
if storeBlockHeight == 0 {
|
2017-02-20 14:08:38 -08:00
|
|
|
return appHash, h.checkAppHash(appHash)
|
2017-02-20 13:24:35 -08:00
|
|
|
|
2016-12-22 12:01:22 -08:00
|
|
|
} else if storeBlockHeight < appBlockHeight {
|
2017-02-20 13:24:35 -08:00
|
|
|
// the app should never be ahead of the store (but this is under app's control)
|
2017-02-20 14:08:38 -08:00
|
|
|
return appHash, ErrAppBlockHeightTooHigh{storeBlockHeight, appBlockHeight}
|
2016-11-19 16:59:56 -08:00
|
|
|
|
2017-02-20 13:24:35 -08:00
|
|
|
} else if storeBlockHeight < stateBlockHeight {
|
|
|
|
// the state should never be ahead of the store (this is under tendermint's control)
|
|
|
|
PanicSanity(Fmt("StateBlockHeight (%d) > StoreBlockHeight (%d)", stateBlockHeight, storeBlockHeight))
|
|
|
|
|
|
|
|
} else if storeBlockHeight > stateBlockHeight+1 {
|
|
|
|
// store should be at most one ahead of the state (this is under tendermint's control)
|
|
|
|
PanicSanity(Fmt("StoreBlockHeight (%d) > StateBlockHeight + 1 (%d)", storeBlockHeight, stateBlockHeight+1))
|
|
|
|
}
|
|
|
|
|
|
|
|
// Now either store is equal to state, or one ahead.
|
|
|
|
// For each, consider all cases of where the app could be, given app <= store
|
|
|
|
if storeBlockHeight == stateBlockHeight {
|
|
|
|
// Tendermint ran Commit and saved the state.
|
|
|
|
// Either the app is asking for replay, or we're all synced up.
|
|
|
|
if appBlockHeight < storeBlockHeight {
|
|
|
|
// the app is behind, so replay blocks, but no need to go through WAL (state is already synced to store)
|
|
|
|
return h.replayBlocks(proxyApp, appBlockHeight, storeBlockHeight, false)
|
|
|
|
|
|
|
|
} else if appBlockHeight == storeBlockHeight {
|
|
|
|
// we're good!
|
2017-02-20 14:08:38 -08:00
|
|
|
return appHash, h.checkAppHash(appHash)
|
2017-02-20 13:24:35 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
} else if storeBlockHeight == stateBlockHeight+1 {
|
|
|
|
// We saved the block in the store but haven't updated the state,
|
|
|
|
// so we'll need to replay a block using the WAL.
|
|
|
|
if appBlockHeight < stateBlockHeight {
|
|
|
|
// the app is further behind than it should be, so replay blocks
|
|
|
|
// but leave the last block to go through the WAL
|
|
|
|
return h.replayBlocks(proxyApp, appBlockHeight, storeBlockHeight, true)
|
|
|
|
|
|
|
|
} else if appBlockHeight == stateBlockHeight {
|
|
|
|
// We haven't run Commit (both the state and app are one block behind),
|
|
|
|
// so run through consensus with the real app
|
|
|
|
log.Info("Replay last block using real app")
|
|
|
|
return h.replayLastBlock(h.config, h.state, proxyApp.Consensus(), h.store)
|
|
|
|
|
|
|
|
} else if appBlockHeight == storeBlockHeight {
|
|
|
|
// We ran Commit, but didn't save the state, so run through consensus with mock app
|
|
|
|
mockApp := newMockProxyApp(appHash)
|
|
|
|
log.Info("Replay last block using mock app")
|
|
|
|
return h.replayLastBlock(h.config, h.state, mockApp, h.store)
|
2017-02-17 08:32:56 -08:00
|
|
|
}
|
|
|
|
|
2017-02-20 13:24:35 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
PanicSanity("Should never happen")
|
|
|
|
return nil, nil
|
|
|
|
}
|
2017-02-18 19:15:59 -08:00
|
|
|
|
2017-02-20 13:24:35 -08:00
|
|
|
func (h *Handshaker) replayBlocks(proxyApp proxy.AppConns, appBlockHeight, storeBlockHeight int, useReplayFunc bool) ([]byte, error) {
|
|
|
|
// App is further behind than it should be, so we need to replay blocks.
|
|
|
|
// We replay all blocks from appBlockHeight+1 to storeBlockHeight-1,
|
|
|
|
// and let the final block be replayed through ReplayBlocks.
|
|
|
|
// Note that we don't have an old version of the state,
|
|
|
|
// so we by-pass state validation using applyBlock here.
|
|
|
|
|
|
|
|
var appHash []byte
|
|
|
|
var err error
|
|
|
|
finalBlock := storeBlockHeight
|
|
|
|
if useReplayFunc {
|
|
|
|
finalBlock -= 1
|
|
|
|
}
|
|
|
|
for i := appBlockHeight + 1; i <= finalBlock; i++ {
|
|
|
|
log.Info("Applying block", "height", i)
|
|
|
|
h.nBlocks += 1
|
|
|
|
block := h.store.LoadBlock(i)
|
|
|
|
appHash, err = applyBlock(proxyApp.Consensus(), block)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
2017-02-17 08:32:56 -08:00
|
|
|
}
|
2016-08-24 21:18:03 -07:00
|
|
|
}
|
2017-02-20 13:24:35 -08:00
|
|
|
|
|
|
|
if useReplayFunc {
|
|
|
|
// sync the final block
|
|
|
|
appHash, err = h.ReplayBlocks(appHash, finalBlock, proxyApp)
|
|
|
|
if err != nil {
|
|
|
|
return appHash, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-20 14:08:38 -08:00
|
|
|
return appHash, h.checkAppHash(appHash)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (h *Handshaker) checkAppHash(appHash []byte) error {
|
2017-02-20 13:24:35 -08:00
|
|
|
if !bytes.Equal(h.state.AppHash, appHash) {
|
2017-02-20 14:08:38 -08:00
|
|
|
return errors.New(Fmt("Tendermint state.AppHash does not match AppHash after replay. Got %X, expected %X", appHash, h.state.AppHash))
|
2017-02-20 13:24:35 -08:00
|
|
|
}
|
2017-02-20 14:08:38 -08:00
|
|
|
return nil
|
2016-08-24 21:18:03 -07:00
|
|
|
}
|
2017-02-16 14:56:45 -08:00
|
|
|
|
|
|
|
//--------------------------------------------------------------------------------
|
|
|
|
|
|
|
|
func newMockProxyApp(appHash []byte) proxy.AppConnConsensus {
|
|
|
|
clientCreator := proxy.NewLocalClientCreator(&mockProxyApp{appHash: appHash})
|
|
|
|
cli, _ := clientCreator.NewABCIClient()
|
|
|
|
return proxy.NewAppConnConsensus(cli)
|
|
|
|
}
|
|
|
|
|
|
|
|
type mockProxyApp struct {
|
|
|
|
abci.BaseApplication
|
|
|
|
|
|
|
|
appHash []byte
|
|
|
|
}
|
|
|
|
|
|
|
|
func (mock *mockProxyApp) Commit() abci.Result {
|
|
|
|
return abci.NewResultOK(mock.appHash, "")
|
|
|
|
}
|