From 6c6e8b0fd7415a43c67699f145e76daff959d745 Mon Sep 17 00:00:00 2001 From: obscuren Date: Wed, 5 Mar 2014 10:57:32 +0100 Subject: [PATCH] Renamed block manager to state manager --- .../{block_manager.go => state_manager.go} | 126 +++++++++--------- ethereum.go | 12 +- 2 files changed, 69 insertions(+), 69 deletions(-) rename ethchain/{block_manager.go => state_manager.go} (69%) diff --git a/ethchain/block_manager.go b/ethchain/state_manager.go similarity index 69% rename from ethchain/block_manager.go rename to ethchain/state_manager.go index fa50304ea..7085146df 100644 --- a/ethchain/block_manager.go +++ b/ethchain/state_manager.go @@ -15,14 +15,14 @@ type BlockProcessor interface { } type EthManager interface { - StateManager() *BlockManager + StateManager() *StateManager BlockChain() *BlockChain TxPool() *TxPool Broadcast(msgType ethwire.MsgType, data []interface{}) } // 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 sync.Mutex @@ -52,8 +52,8 @@ type BlockManager struct { compState *State } -func NewBlockManager(ethereum EthManager) *BlockManager { - bm := &BlockManager{ +func NewStateManager(ethereum EthManager) *StateManager { + sm := &StateManager{ stack: NewStack(), mem: make(map[string]*big.Int), Pow: &EasyPow{}, @@ -62,57 +62,57 @@ func NewBlockManager(ethereum EthManager) *BlockManager { bc: ethereum.BlockChain(), } - return bm + return sm } -func (bm *BlockManager) ProcState() *State { - return bm.procState +func (sm *StateManager) ProcState() *State { + return sm.procState } // Watches any given address and puts it in the address state store -func (bm *BlockManager) WatchAddr(addr []byte) *AccountState { - //FIXME account := bm.procState.GetAccount(addr) - account := bm.bc.CurrentBlock.state.GetAccount(addr) +func (sm *StateManager) WatchAddr(addr []byte) *AccountState { + //FIXME account := sm.procState.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 { - account := bm.addrStateStore.Get(addr) +func (sm *StateManager) GetAddrState(addr []byte) *AccountState { + account := sm.addrStateStore.Get(addr) if account == nil { - a := bm.bc.CurrentBlock.state.GetAccount(addr) + a := sm.bc.CurrentBlock.state.GetAccount(addr) account = &AccountState{Nonce: a.Nonce, Account: a} } return account } -func (bm *BlockManager) BlockChain() *BlockChain { - return bm.bc +func (sm *StateManager) BlockChain() *BlockChain { + return sm.bc } -func (bm *BlockManager) MakeContract(tx *Transaction) { - contract := MakeContract(tx, bm.procState) +func (sm *StateManager) MakeContract(tx *Transaction) { + contract := MakeContract(tx, sm.procState) 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 for _, tx := range txs { // If there's no recipient, it's a contract if tx.IsContract() { - //FIXME bm.MakeContract(tx) + //FIXME sm.MakeContract(tx) block.MakeContract(tx) } else { //FIXME if contract := procState.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 { - err := bm.Ethereum.TxPool().ProcessTransaction(tx, block) + err := sm.Ethereum.TxPool().ProcessTransaction(tx, block) 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 // "ProcessBlock" action. -func (bm *BlockManager) Prepare(processer *State, comparative *State) { - bm.compState = comparative - bm.procState = processer +func (sm *StateManager) Prepare(processer *State, comparative *State) { + sm.compState = comparative + sm.procState = processer } // Default prepare function -func (bm *BlockManager) PrepareDefault(block *Block) { - bm.Prepare(bm.BlockChain().CurrentBlock.State(), block.State()) +func (sm *StateManager) PrepareDefault(block *Block) { + sm.Prepare(sm.BlockChain().CurrentBlock.State(), block.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 - bm.mutex.Lock() - defer bm.mutex.Unlock() + sm.mutex.Lock() + defer sm.mutex.Unlock() // Defer the Undo on the Trie. If the block processing happened // we don't want to undo but since undo only happens on dirty // nodes this won't happen because Commit would have been called // before that. - defer bm.bc.CurrentBlock.Undo() + defer sm.bc.CurrentBlock.Undo() hash := block.Hash() - if bm.bc.HasBlock(hash) { + if sm.bc.HasBlock(hash) { return nil } // 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 - if !bm.bc.HasBlock(block.PrevHash) && bm.bc.CurrentBlock != nil { + if !sm.bc.HasBlock(block.PrevHash) && sm.bc.CurrentBlock != nil { return ParentError(block.PrevHash) } // Process the transactions on to current block - bm.ApplyTransactions(bm.bc.CurrentBlock, block.Transactions()) + sm.ApplyTransactions(sm.bc.CurrentBlock, block.Transactions()) // Block validation - if err := bm.ValidateBlock(block); err != nil { + if err := sm.ValidateBlock(block); err != nil { return err } // I'm not sure, but I don't know if there should be thrown // 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 } - // if !bm.compState.Cmp(bm.procState) - if !block.state.Cmp(bm.bc.CurrentBlock.state) { - return fmt.Errorf("Invalid merkle root. Expected %x, got %x", block.State().trie.Root, bm.bc.CurrentBlock.State().trie.Root) - //FIXME return fmt.Errorf("Invalid merkle root. Expected %x, got %x", bm.compState.trie.Root, bm.procState.trie.Root) + // if !sm.compState.Cmp(sm.procState) + if !block.state.Cmp(sm.bc.CurrentBlock.state) { + 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", sm.compState.trie.Root, sm.procState.trie.Root) } // 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 - bm.bc.CurrentBlock.Sync() - //FIXME bm.procState.Sync() + sm.bc.CurrentBlock.Sync() + //FIXME sm.procState.Sync() // 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 - bm.bc.Add(block) + sm.bc.Add(block) // If there's a block processor present, pass in the block for further // processing - if bm.SecondaryBlockProcessor != nil { - bm.SecondaryBlockProcessor.ProcessBlock(block) + if sm.SecondaryBlockProcessor != nil { + 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 { fmt.Println("total diff failed") } @@ -200,7 +200,7 @@ func (bm *BlockManager) ProcessBlock(block *Block) error { return nil } -func (bm *BlockManager) CalculateTD(block *Block) bool { +func (sm *StateManager) CalculateTD(block *Block) bool { uncleDiff := new(big.Int) for _, uncle := range block.Uncles { 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 := new(big.Int) - td = td.Add(bm.bc.TD, uncleDiff) + td = td.Add(sm.bc.TD, uncleDiff) td = td.Add(td, block.Difficulty) // The new TD will only be accepted if the new difficulty is // 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 - bm.bc.SetTotalDifficulty(td) + sm.bc.SetTotalDifficulty(td) 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, // an uncle or anything that isn't on the current block chain. // 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 // 2. Check if the difficulty is correct // Check each uncle's previous hash. In order for it to be valid // 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 { if bytes.Compare(uncle.PrevHash, previousBlock.PrevHash) != 0 { 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 { 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 - 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) } @@ -269,7 +269,7 @@ func CalculateUncleReward(block *Block) *big.Int { 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 addr := processor.state.GetAccount(block.Coinbase) //FIXME addr := proc.GetAccount(block.Coinbase) @@ -290,11 +290,11 @@ func (bm *BlockManager) AccumelateRewards(processor *Block, block *Block) error return nil } -func (bm *BlockManager) Stop() { - bm.bc.Stop() +func (sm *StateManager) 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 /* defer func() { @@ -305,7 +305,7 @@ func (bm *BlockManager) ProcessContract(contract *Contract, tx *Transaction, blo */ vm := &Vm{} - //vm.Process(contract, bm.procState, RuntimeVars{ + //vm.Process(contract, sm.procState, RuntimeVars{ vm.Process(contract, block.state, RuntimeVars{ address: tx.Hash()[12:], blockNumber: block.BlockInfo().Number, diff --git a/ethereum.go b/ethereum.go index 2c8b2cceb..342f4f573 100644 --- a/ethereum.go +++ b/ethereum.go @@ -36,8 +36,8 @@ type Ethereum struct { // DB interface //db *ethdb.LDBDatabase db ethutil.Database - // Block manager for processing new blocks and managing the block chain - blockManager *ethchain.BlockManager + // State manager for processing new blocks and managing the over all states + stateManager *ethchain.StateManager // The transaction pool. Transaction can be pushed on this pool // for later including in the blocks txPool *ethchain.TxPool @@ -91,7 +91,7 @@ func New(caps Caps, usePnp bool) (*Ethereum, error) { } ethereum.txPool = ethchain.NewTxPool(ethereum) ethereum.blockChain = ethchain.NewBlockChain(ethereum) - ethereum.blockManager = ethchain.NewBlockManager(ethereum) + ethereum.stateManager = ethchain.NewStateManager(ethereum) // Start the tx pool ethereum.txPool.Start() @@ -103,8 +103,8 @@ func (s *Ethereum) BlockChain() *ethchain.BlockChain { return s.blockChain } -func (s *Ethereum) StateManager() *ethchain.BlockManager { - return s.blockManager +func (s *Ethereum) StateManager() *ethchain.StateManager { + return s.stateManager } func (s *Ethereum) TxPool() *ethchain.TxPool { @@ -304,7 +304,7 @@ func (s *Ethereum) Stop() { close(s.quit) s.txPool.Stop() - s.blockManager.Stop() + s.stateManager.Stop() close(s.shutdownChan) }