poanetwork
/
quorum
mirror of https://github.com/poanetwork/quorum.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Renamed block manager to state manager

This commit is contained in:
obscuren 2014-03-05 10:57:32 +01:00
parent 79320e2868
commit 6c6e8b0fd7
2 changed files with 69 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

126
ethchain/block_manager.go → ethchain/state_manager.go
View File

@ -15,14 +15,14 @@ type BlockProcessor interface {
} }
type EthManager interface { type EthManager interface {
StateManager() *BlockManager StateManager() *StateManager
BlockChain() *BlockChain BlockChain() *BlockChain
TxPool() *TxPool TxPool() *TxPool
Broadcast(msgType ethwire.MsgType, data []interface{}) Broadcast(msgType ethwire.MsgType, data []interface{})
} }
// TODO rename to state manager // TODO rename to state manager
type BlockManager struct { type StateManager struct {
// Mutex for locking the block processor. Blocks can only be handled one at a time // Mutex for locking the block processor. Blocks can only be handled one at a time
mutex sync.Mutex mutex sync.Mutex
@ -52,8 +52,8 @@ type BlockManager struct {
compState *State compState *State
} }
func NewBlockManager(ethereum EthManager) *BlockManager { func NewStateManager(ethereum EthManager) *StateManager {
bm := &BlockManager{ sm := &StateManager{
stack: NewStack(), stack: NewStack(),
mem: make(map[string]*big.Int), mem: make(map[string]*big.Int),
Pow: &EasyPow{}, Pow: &EasyPow{},
@ -62,57 +62,57 @@ func NewBlockManager(ethereum EthManager) *BlockManager {
bc: ethereum.BlockChain(), bc: ethereum.BlockChain(),
} }
return bm return sm
} }
func (bm *BlockManager) ProcState() *State { func (sm *StateManager) ProcState() *State {
return bm.procState return sm.procState
} }
// Watches any given address and puts it in the address state store // Watches any given address and puts it in the address state store
func (bm *BlockManager) WatchAddr(addr []byte) *AccountState { func (sm *StateManager) WatchAddr(addr []byte) *AccountState {
//FIXME account := bm.procState.GetAccount(addr) //FIXME account := sm.procState.GetAccount(addr)
account := bm.bc.CurrentBlock.state.GetAccount(addr) account := sm.bc.CurrentBlock.state.GetAccount(addr)
return bm.addrStateStore.Add(addr, account) return sm.addrStateStore.Add(addr, account)
} }
func (bm *BlockManager) GetAddrState(addr []byte) *AccountState { func (sm *StateManager) GetAddrState(addr []byte) *AccountState {
account := bm.addrStateStore.Get(addr) account := sm.addrStateStore.Get(addr)
if account == nil { if account == nil {
a := bm.bc.CurrentBlock.state.GetAccount(addr) a := sm.bc.CurrentBlock.state.GetAccount(addr)
account = &AccountState{Nonce: a.Nonce, Account: a} account = &AccountState{Nonce: a.Nonce, Account: a}
} }
return account return account
} }
func (bm *BlockManager) BlockChain() *BlockChain { func (sm *StateManager) BlockChain() *BlockChain {
return bm.bc return sm.bc
} }
func (bm *BlockManager) MakeContract(tx *Transaction) { func (sm *StateManager) MakeContract(tx *Transaction) {
contract := MakeContract(tx, bm.procState) contract := MakeContract(tx, sm.procState)
if contract != nil { if contract != nil {
bm.procState.states[string(tx.Hash()[12:])] = contract.state sm.procState.states[string(tx.Hash()[12:])] = contract.state
} }
} }
func (bm *BlockManager) ApplyTransactions(block *Block, txs []*Transaction) { func (sm *StateManager) ApplyTransactions(block *Block, txs []*Transaction) {
// Process each transaction/contract // Process each transaction/contract
for _, tx := range txs { for _, tx := range txs {
// If there's no recipient, it's a contract // If there's no recipient, it's a contract
if tx.IsContract() { if tx.IsContract() {
//FIXME bm.MakeContract(tx) //FIXME sm.MakeContract(tx)
block.MakeContract(tx) block.MakeContract(tx)
} else { } else {
//FIXME if contract := procState.GetContract(tx.Recipient); contract != nil { //FIXME if contract := procState.GetContract(tx.Recipient); contract != nil {
if contract := block.state.GetContract(tx.Recipient); contract != nil { if contract := block.state.GetContract(tx.Recipient); contract != nil {
bm.ProcessContract(contract, tx, block) sm.ProcessContract(contract, tx, block)
} else { } else {
err := bm.Ethereum.TxPool().ProcessTransaction(tx, block) err := sm.Ethereum.TxPool().ProcessTransaction(tx, block)
if err != nil { if err != nil {
ethutil.Config.Log.Infoln("[BMGR]", err) ethutil.Config.Log.Infoln("[smGR]", err)
} }
} }
} }
@ -121,78 +121,78 @@ func (bm *BlockManager) ApplyTransactions(block *Block, txs []*Transaction) {
// The prepare function, prepares the state manager for the next // The prepare function, prepares the state manager for the next
// "ProcessBlock" action. // "ProcessBlock" action.
func (bm *BlockManager) Prepare(processer *State, comparative *State) { func (sm *StateManager) Prepare(processer *State, comparative *State) {
bm.compState = comparative sm.compState = comparative
bm.procState = processer sm.procState = processer
} }
// Default prepare function // Default prepare function
func (bm *BlockManager) PrepareDefault(block *Block) { func (sm *StateManager) PrepareDefault(block *Block) {
bm.Prepare(bm.BlockChain().CurrentBlock.State(), block.State()) sm.Prepare(sm.BlockChain().CurrentBlock.State(), block.State())
} }
// Block processing and validating with a given (temporarily) state // Block processing and validating with a given (temporarily) state
func (bm *BlockManager) ProcessBlock(block *Block) error { func (sm *StateManager) ProcessBlock(block *Block) error {
// Processing a blocks may never happen simultaneously // Processing a blocks may never happen simultaneously
bm.mutex.Lock() sm.mutex.Lock()
defer bm.mutex.Unlock() defer sm.mutex.Unlock()
// Defer the Undo on the Trie. If the block processing happened // Defer the Undo on the Trie. If the block processing happened
// we don't want to undo but since undo only happens on dirty // we don't want to undo but since undo only happens on dirty
// nodes this won't happen because Commit would have been called // nodes this won't happen because Commit would have been called
// before that. // before that.
defer bm.bc.CurrentBlock.Undo() defer sm.bc.CurrentBlock.Undo()
hash := block.Hash() hash := block.Hash()
if bm.bc.HasBlock(hash) { if sm.bc.HasBlock(hash) {
return nil return nil
} }
// Check if we have the parent hash, if it isn't known we discard it // Check if we have the parent hash, if it isn't known we discard it
// Reasons might be catching up or simply an invalid block // Reasons might be catching up or simply an invalid block
if !bm.bc.HasBlock(block.PrevHash) && bm.bc.CurrentBlock != nil { if !sm.bc.HasBlock(block.PrevHash) && sm.bc.CurrentBlock != nil {
return ParentError(block.PrevHash) return ParentError(block.PrevHash)
} }
// Process the transactions on to current block // Process the transactions on to current block
bm.ApplyTransactions(bm.bc.CurrentBlock, block.Transactions()) sm.ApplyTransactions(sm.bc.CurrentBlock, block.Transactions())
// Block validation // Block validation
if err := bm.ValidateBlock(block); err != nil { if err := sm.ValidateBlock(block); err != nil {
return err return err
} }
// I'm not sure, but I don't know if there should be thrown // I'm not sure, but I don't know if there should be thrown
// any errors at this time. // any errors at this time.
if err := bm.AccumelateRewards(bm.bc.CurrentBlock, block); err != nil { if err := sm.AccumelateRewards(sm.bc.CurrentBlock, block); err != nil {
return err return err
} }
// if !bm.compState.Cmp(bm.procState) // if !sm.compState.Cmp(sm.procState)
if !block.state.Cmp(bm.bc.CurrentBlock.state) { if !block.state.Cmp(sm.bc.CurrentBlock.state) {
return fmt.Errorf("Invalid merkle root. Expected %x, got %x", block.State().trie.Root, bm.bc.CurrentBlock.State().trie.Root) return fmt.Errorf("Invalid merkle root. Expected %x, got %x", block.State().trie.Root, sm.bc.CurrentBlock.State().trie.Root)
//FIXME return fmt.Errorf("Invalid merkle root. Expected %x, got %x", bm.compState.trie.Root, bm.procState.trie.Root) //FIXME return fmt.Errorf("Invalid merkle root. Expected %x, got %x", sm.compState.trie.Root, sm.procState.trie.Root)
} }
// Calculate the new total difficulty and sync back to the db // Calculate the new total difficulty and sync back to the db
if bm.CalculateTD(block) { if sm.CalculateTD(block) {
// Sync the current block's state to the database and cancelling out the deferred Undo // Sync the current block's state to the database and cancelling out the deferred Undo
bm.bc.CurrentBlock.Sync() sm.bc.CurrentBlock.Sync()
//FIXME bm.procState.Sync() //FIXME sm.procState.Sync()
// Broadcast the valid block back to the wire // Broadcast the valid block back to the wire
//bm.Ethereum.Broadcast(ethwire.MsgBlockTy, []interface{}{block.Value().Val}) //sm.Ethereum.Broadcast(ethwire.MsgBlockTy, []interface{}{block.Value().Val})
// Add the block to the chain // Add the block to the chain
bm.bc.Add(block) sm.bc.Add(block)
// If there's a block processor present, pass in the block for further // If there's a block processor present, pass in the block for further
// processing // processing
if bm.SecondaryBlockProcessor != nil { if sm.SecondaryBlockProcessor != nil {
bm.SecondaryBlockProcessor.ProcessBlock(block) sm.SecondaryBlockProcessor.ProcessBlock(block)
} }
ethutil.Config.Log.Infof("[BMGR] Added block #%d (%x)\n", block.BlockInfo().Number, block.Hash()) ethutil.Config.Log.Infof("[smGR] Added block #%d (%x)\n", block.BlockInfo().Number, block.Hash())
} else { } else {
fmt.Println("total diff failed") fmt.Println("total diff failed")
} }
@ -200,7 +200,7 @@ func (bm *BlockManager) ProcessBlock(block *Block) error {
return nil return nil
} }
func (bm *BlockManager) CalculateTD(block *Block) bool { func (sm *StateManager) CalculateTD(block *Block) bool {
uncleDiff := new(big.Int) uncleDiff := new(big.Int)
for _, uncle := range block.Uncles { for _, uncle := range block.Uncles {
uncleDiff = uncleDiff.Add(uncleDiff, uncle.Difficulty) uncleDiff = uncleDiff.Add(uncleDiff, uncle.Difficulty)
@ -208,14 +208,14 @@ func (bm *BlockManager) CalculateTD(block *Block) bool {
// TD(genesis_block) = 0 and TD(B) = TD(B.parent) + sum(u.difficulty for u in B.uncles) + B.difficulty // TD(genesis_block) = 0 and TD(B) = TD(B.parent) + sum(u.difficulty for u in B.uncles) + B.difficulty
td := new(big.Int) td := new(big.Int)
td = td.Add(bm.bc.TD, uncleDiff) td = td.Add(sm.bc.TD, uncleDiff)
td = td.Add(td, block.Difficulty) td = td.Add(td, block.Difficulty)
// The new TD will only be accepted if the new difficulty is // The new TD will only be accepted if the new difficulty is
// is greater than the previous. // is greater than the previous.
if td.Cmp(bm.bc.TD) > 0 { if td.Cmp(sm.bc.TD) > 0 {
// Set the new total difficulty back to the block chain // Set the new total difficulty back to the block chain
bm.bc.SetTotalDifficulty(td) sm.bc.SetTotalDifficulty(td)
return true return true
} }
@ -226,20 +226,20 @@ func (bm *BlockManager) CalculateTD(block *Block) bool {
// Validates the current block. Returns an error if the block was invalid, // Validates the current block. Returns an error if the block was invalid,
// an uncle or anything that isn't on the current block chain. // an uncle or anything that isn't on the current block chain.
// Validation validates easy over difficult (dagger takes longer time = difficult) // Validation validates easy over difficult (dagger takes longer time = difficult)
func (bm *BlockManager) ValidateBlock(block *Block) error { func (sm *StateManager) ValidateBlock(block *Block) error {
// TODO // TODO
// 2. Check if the difficulty is correct // 2. Check if the difficulty is correct
// Check each uncle's previous hash. In order for it to be valid // Check each uncle's previous hash. In order for it to be valid
// is if it has the same block hash as the current // is if it has the same block hash as the current
previousBlock := bm.bc.GetBlock(block.PrevHash) previousBlock := sm.bc.GetBlock(block.PrevHash)
for _, uncle := range block.Uncles { for _, uncle := range block.Uncles {
if bytes.Compare(uncle.PrevHash, previousBlock.PrevHash) != 0 { if bytes.Compare(uncle.PrevHash, previousBlock.PrevHash) != 0 {
return ValidationError("Mismatch uncle's previous hash. Expected %x, got %x", previousBlock.PrevHash, uncle.PrevHash) return ValidationError("Mismatch uncle's previous hash. Expected %x, got %x", previousBlock.PrevHash, uncle.PrevHash)
} }
} }
diff := block.Time - bm.bc.CurrentBlock.Time diff := block.Time - sm.bc.CurrentBlock.Time
if diff < 0 { if diff < 0 {
return ValidationError("Block timestamp less then prev block %v", diff) return ValidationError("Block timestamp less then prev block %v", diff)
} }
@ -250,7 +250,7 @@ func (bm *BlockManager) ValidateBlock(block *Block) error {
} }
// Verify the nonce of the block. Return an error if it's not valid // Verify the nonce of the block. Return an error if it's not valid
if !bm.Pow.Verify(block.HashNoNonce(), block.Difficulty, block.Nonce) { if !sm.Pow.Verify(block.HashNoNonce(), block.Difficulty, block.Nonce) {
return ValidationError("Block's nonce is invalid (= %v)", block.Nonce) return ValidationError("Block's nonce is invalid (= %v)", block.Nonce)
} }
@ -269,7 +269,7 @@ func CalculateUncleReward(block *Block) *big.Int {
return UncleReward return UncleReward
} }
func (bm *BlockManager) AccumelateRewards(processor *Block, block *Block) error { func (sm *StateManager) AccumelateRewards(processor *Block, block *Block) error {
// Get the coinbase rlp data // Get the coinbase rlp data
addr := processor.state.GetAccount(block.Coinbase) addr := processor.state.GetAccount(block.Coinbase)
//FIXME addr := proc.GetAccount(block.Coinbase) //FIXME addr := proc.GetAccount(block.Coinbase)
@ -290,11 +290,11 @@ func (bm *BlockManager) AccumelateRewards(processor *Block, block *Block) error
return nil return nil
} }
func (bm *BlockManager) Stop() { func (sm *StateManager) Stop() {
bm.bc.Stop() sm.bc.Stop()
} }
func (bm *BlockManager) ProcessContract(contract *Contract, tx *Transaction, block *Block) { func (sm *StateManager) ProcessContract(contract *Contract, tx *Transaction, block *Block) {
// Recovering function in case the VM had any errors // Recovering function in case the VM had any errors
/* /*
defer func() { defer func() {
@ -305,7 +305,7 @@ func (bm *BlockManager) ProcessContract(contract *Contract, tx *Transaction, blo
*/ */
vm := &Vm{} vm := &Vm{}
//vm.Process(contract, bm.procState, RuntimeVars{ //vm.Process(contract, sm.procState, RuntimeVars{
vm.Process(contract, block.state, RuntimeVars{ vm.Process(contract, block.state, RuntimeVars{
address: tx.Hash()[12:], address: tx.Hash()[12:],
blockNumber: block.BlockInfo().Number, blockNumber: block.BlockInfo().Number,

12
ethereum.go
View File

@ -36,8 +36,8 @@ type Ethereum struct {
// DB interface // DB interface
//db *ethdb.LDBDatabase //db *ethdb.LDBDatabase
db ethutil.Database db ethutil.Database
// Block manager for processing new blocks and managing the block chain // State manager for processing new blocks and managing the over all states
blockManager *ethchain.BlockManager stateManager *ethchain.StateManager
// The transaction pool. Transaction can be pushed on this pool // The transaction pool. Transaction can be pushed on this pool
// for later including in the blocks // for later including in the blocks
txPool *ethchain.TxPool txPool *ethchain.TxPool
@ -91,7 +91,7 @@ func New(caps Caps, usePnp bool) (*Ethereum, error) {
} }
ethereum.txPool = ethchain.NewTxPool(ethereum) ethereum.txPool = ethchain.NewTxPool(ethereum)
ethereum.blockChain = ethchain.NewBlockChain(ethereum) ethereum.blockChain = ethchain.NewBlockChain(ethereum)
ethereum.blockManager = ethchain.NewBlockManager(ethereum) ethereum.stateManager = ethchain.NewStateManager(ethereum)
// Start the tx pool // Start the tx pool
ethereum.txPool.Start() ethereum.txPool.Start()
@ -103,8 +103,8 @@ func (s *Ethereum) BlockChain() *ethchain.BlockChain {
return s.blockChain return s.blockChain
} }
func (s *Ethereum) StateManager() *ethchain.BlockManager { func (s *Ethereum) StateManager() *ethchain.StateManager {
return s.blockManager return s.stateManager
} }
func (s *Ethereum) TxPool() *ethchain.TxPool { func (s *Ethereum) TxPool() *ethchain.TxPool {
@ -304,7 +304,7 @@ func (s *Ethereum) Stop() {
close(s.quit) close(s.quit)
s.txPool.Stop() s.txPool.Stop()
s.blockManager.Stop() s.stateManager.Stop()
close(s.shutdownChan) close(s.shutdownChan)
} }