headrush
/
go-ethereum
forked from mirror/go-ethereum
1
1
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Renamed block manager to state manager

Browse Source
poc8
obscuren 11 years ago
parent 79320e2868
commit 6c6e8b0fd7
2 changed files with 69 additions and 69 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 126
      ethchain/state_manager.go
  2. 12
      ethereum.go

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

@ -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,

12
ethereum.go
Unescape View File

@ -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)
}

Write Preview
Loading…
Cancel
Save