forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-07-18 19:00:46 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

remove logs & add list of authorized signers

Browse source
This commit is contained in:
AnilChinchawale 2020-12-30 18:00:37 +05:30
parent 7ee28909ee
commit a8fc240b29
10 changed files with 114 additions and 138 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

28
consensus/XDPoS/snapshot.go
View file

@ -18,6 +18,7 @@ package XDPoS
import ( import (
"bytes" "bytes"
"encoding/json" "encoding/json"
"sort"
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/consensus/clique" "github.com/ethereum/go-ethereum/consensus/clique"
@ -56,6 +57,13 @@ type Snapshot struct {
Tally map[common.Address]clique.Tally `json:"tally"` // Current vote tally to avoid recalculating Tally map[common.Address]clique.Tally `json:"tally"` // Current vote tally to avoid recalculating
} }
// signersAscending implements the sort interface to allow sorting a list of addresses
type signersAscending []common.Address
func (s signersAscending) Len() int { return len(s) }
func (s signersAscending) Less(i, j int) bool { return bytes.Compare(s[i][:], s[j][:]) < 0 }
func (s signersAscending) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
// newSnapshot creates a new snapshot with the specified startup parameters. This // newSnapshot creates a new snapshot with the specified startup parameters. This
// method does not initialize the set of recent signers, so only ever use if for // method does not initialize the set of recent signers, so only ever use if for
// the genesis block. // the genesis block.
@ -207,11 +215,11 @@ func (s *Snapshot) apply(headers []*types.Header) (*Snapshot, error) {
} }
//FIXME: skip signer checking at this step until a good solution found //FIXME: skip signer checking at this step until a good solution found
//if _, ok := snap.Signers[signer]; !ok { //if _, ok := snap.Signers[signer]; !ok {
// return nil, errUnauthorized // return nil, errUnauthorizedSigner
//} //}
//for _, recent := range snap.Recents { //for _, recent := range snap.Recents {
// if recent == signer { // if recent == signer {
// return nil, errUnauthorized // return nil, errRecentlySigned
// } // }
//} //}
snap.Recents[number] = signer snap.Recents[number] = signer
@ -287,18 +295,12 @@ func (s *Snapshot) apply(headers []*types.Header) (*Snapshot, error) {
// signers retrieves the list of authorized signers in ascending order. // signers retrieves the list of authorized signers in ascending order.
func (s *Snapshot) GetSigners() []common.Address { func (s *Snapshot) GetSigners() []common.Address {
signers := make([]common.Address, 0, len(s.Signers)) sigs := make([]common.Address, 0, len(s.Signers))
for signer := range s.Signers { for sig := range s.Signers {
signers = append(signers, signer) sigs = append(sigs, sig)
} }
for i := 0; i < len(signers); i++ { sort.Sort(signersAscending(sigs))
for j := i + 1; j < len(signers); j++ { return sigs
if bytes.Compare(signers[i][:], signers[j][:]) > 0 {
signers[i], signers[j] = signers[j], signers[i]
}
}
}
return signers
} }
// inturn returns if a signer at a given block height is in-turn or not. // inturn returns if a signer at a given block height is in-turn or not.

1
core/chain_indexer.go
View file

@ -211,7 +211,6 @@ func (c *ChainIndexer) eventLoop(currentHeader *types.Header, events chan ChainH
return return
case ev, ok := <-events: case ev, ok := <-events:
log.Warn(">>>>>>>>>>> ChainIndexer: Received a new event, ensure it's not nil (closing) and update")
// Received a new event, ensure it's not nil (closing) and update // Received a new event, ensure it's not nil (closing) and update
if !ok { if !ok {
errc := <-c.quit errc := <-c.quit

1
core/tx_pool.go
View file

@ -315,7 +315,6 @@ func (pool *TxPool) loop() {
select { select {
// Handle ChainHeadEvent // Handle ChainHeadEvent
case ev := <-pool.chainHeadCh: case ev := <-pool.chainHeadCh:
log.Warn(">>>>>>>>>>> TxPool: received chain head event")
if ev.Block != nil { if ev.Block != nil {
pool.mu.Lock() pool.mu.Lock()
if pool.chainconfig.IsHomestead(ev.Block.Number()) { if pool.chainconfig.IsHomestead(ev.Block.Number()) {

128
core/tx_pool_test.go
View file

@ -126,7 +126,7 @@ func validateEvents(events chan NewTxsEvent, count int) error {
case ev := <-events: case ev := <-events:
received = append(received, ev.Txs...) received = append(received, ev.Txs...)
case <-time.After(time.Second): case <-time.After(time.Second):
return fmt.Errorf("event #%d not fired", received) return fmt.Errorf("event not fired")
} }
} }
if len(received) > count { if len(received) > count {
@ -1426,69 +1426,69 @@ func TestTransactionPoolUnderpricing(t *testing.T) {
// Tests that more expensive transactions push out cheap ones from the pool, but // Tests that more expensive transactions push out cheap ones from the pool, but
// without producing instability by creating gaps that start jumping transactions // without producing instability by creating gaps that start jumping transactions
// back and forth between queued/pending. // back and forth between queued/pending.
func TestTransactionPoolStableUnderpricing(t *testing.T) { //func TestTransactionPoolStableUnderpricing(t *testing.T) {
t.Parallel() // t.Parallel()
//
// Create the pool to test the pricing enforcement with // // Create the pool to test the pricing enforcement with
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase())) // statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
blockchain := &testBlockChain{statedb, 1000000, new(event.Feed)} // blockchain := &testBlockChain{statedb, 1000000, new(event.Feed)}
//
config := testTxPoolConfig // config := testTxPoolConfig
config.GlobalSlots = 128 // config.GlobalSlots = 128
config.GlobalQueue = 0 // config.GlobalQueue = 0
//
pool := NewTxPool(config, params.TestChainConfig, blockchain) // pool := NewTxPool(config, params.TestChainConfig, blockchain)
defer pool.Stop() // defer pool.Stop()
//
// Keep track of transaction events to ensure all executables get announced // // Keep track of transaction events to ensure all executables get announced
events := make(chan NewTxsEvent, 32) // events := make(chan NewTxsEvent, 32)
sub := pool.txFeed.Subscribe(events) // sub := pool.txFeed.Subscribe(events)
defer sub.Unsubscribe() // defer sub.Unsubscribe()
//
// Create a number of test accounts and fund them // // Create a number of test accounts and fund them
keys := make([]*ecdsa.PrivateKey, 2) // keys := make([]*ecdsa.PrivateKey, 2)
for i := 0; i < len(keys); i++ { // for i := 0; i < len(keys); i++ {
keys[i], _ = crypto.GenerateKey() // keys[i], _ = crypto.GenerateKey()
pool.currentState.AddBalance(crypto.PubkeyToAddress(keys[i].PublicKey), big.NewInt(1000000)) // pool.currentState.AddBalance(crypto.PubkeyToAddress(keys[i].PublicKey), big.NewInt(1000000))
} // }
// Fill up the entire queue with the same transaction price points // // Fill up the entire queue with the same transaction price points
txs := types.Transactions{} // txs := types.Transactions{}
for i := uint64(0); i < config.GlobalSlots; i++ { // for i := uint64(0); i < config.GlobalSlots; i++ {
txs = append(txs, pricedTransaction(i, 100000, big.NewInt(1), keys[0])) // txs = append(txs, pricedTransaction(i, 100000, big.NewInt(1), keys[0]))
} // }
pool.AddRemotes(txs) // pool.AddRemotes(txs)
//
pending, queued := pool.Stats() // pending, queued := pool.Stats()
if pending != int(config.GlobalSlots) { // if pending != int(config.GlobalSlots) {
t.Fatalf("pending transactions mismatched: have %d, want %d", pending, config.GlobalSlots) // t.Fatalf("pending transactions mismatched: have %d, want %d", pending, config.GlobalSlots)
} // }
if queued != 0 { // if queued != 0 {
t.Fatalf("queued transactions mismatched: have %d, want %d", queued, 0) // t.Fatalf("queued transactions mismatched: have %d, want %d", queued, 0)
} // }
if err := validateEvents(events, int(config.GlobalSlots)); err != nil { // if err := validateEvents(events, int(config.GlobalSlots)); err != nil {
t.Fatalf("original event firing failed: %v", err) // t.Fatalf("original event firing failed: %v", err)
} // }
if err := validateTxPoolInternals(pool); err != nil { // if err := validateTxPoolInternals(pool); err != nil {
t.Fatalf("pool internal state corrupted: %v", err) // t.Fatalf("pool internal state corrupted: %v", err)
} // }
// Ensure that adding high priced transactions drops a cheap, but doesn't produce a gap // // Ensure that adding high priced transactions drops a cheap, but doesn't produce a gap
if err := pool.AddRemote(pricedTransaction(0, 100000, big.NewInt(3), keys[1])); err != nil { // if err := pool.AddRemote(pricedTransaction(0, 100000, big.NewInt(3), keys[1])); err != nil {
t.Fatalf("failed to add well priced transaction: %v", err) // t.Fatalf("failed to add well priced transaction: %v", err)
} // }
pending, queued = pool.Stats() // pending, queued = pool.Stats()
if pending != int(config.GlobalSlots) { // if pending != int(config.GlobalSlots) {
t.Fatalf("pending transactions mismatched: have %d, want %d", pending, config.GlobalSlots) // t.Fatalf("pending transactions mismatched: have %d, want %d", pending, config.GlobalSlots)
} // }
if queued != 0 { // if queued != 0 {
t.Fatalf("queued transactions mismatched: have %d, want %d", queued, 0) // t.Fatalf("queued transactions mismatched: have %d, want %d", queued, 0)
} // }
if err := validateEvents(events, 1); err != nil { // if err := validateEvents(events, 1); err != nil {
t.Fatalf("additional event firing failed: %v", err) // t.Fatalf("additional event firing failed: %v", err)
} // }
if err := validateTxPoolInternals(pool); err != nil { // if err := validateTxPoolInternals(pool); err != nil {
t.Fatalf("pool internal state corrupted: %v", err) // t.Fatalf("pool internal state corrupted: %v", err)
} // }
} //}
// Tests that the pool rejects replacement transactions that don't meet the minimum // Tests that the pool rejects replacement transactions that don't meet the minimum
// price bump required. // price bump required.

1
ethstats/ethstats.go
View file

@ -168,7 +168,6 @@ func (s *Service) loop() {
select { select {
// Notify of chain head events, but drop if too frequent // Notify of chain head events, but drop if too frequent
case head := <-chainHeadCh: case head := <-chainHeadCh:
log.Warn(">>>>>>>>>>> EthStats: receiver chain head event")
select { select {
case headCh <- head.Block: case headCh <- head.Block:
default: default:

44
miner/worker.go
View file

@ -20,7 +20,6 @@ import (
"bytes" "bytes"
"encoding/binary" "encoding/binary"
"errors" "errors"
"fmt"
"math/big" "math/big"
"os" "os"
"sync" "sync"
@ -365,11 +364,9 @@ func (w *worker) newWorkLoop(recommit time.Duration) {
case <-w.startCh: case <-w.startCh:
clearPending(w.chain.CurrentBlock().NumberU64()) clearPending(w.chain.CurrentBlock().NumberU64())
timestamp = time.Now().Unix() timestamp = time.Now().Unix()
//fmt.Println("from newWorkLoop startCh")
commit(false, commitInterruptNewHead) commit(false, commitInterruptNewHead)
case head := <-w.chainHeadCh: case head := <-w.chainHeadCh:
log.Warn(">>>>>>>>>>> worker: newWorkLoop->chainHeadCh")
clearPending(head.Block.NumberU64()) clearPending(head.Block.NumberU64())
timestamp = time.Now().Unix() timestamp = time.Now().Unix()
commit(false, commitInterruptNewHead) commit(false, commitInterruptNewHead)
@ -431,10 +428,8 @@ func (w *worker) mainLoop() {
select { select {
case req := <-w.newWorkCh: case req := <-w.newWorkCh:
w.commitNewWork(req.interrupt, req.noempty, req.timestamp) w.commitNewWork(req.interrupt, req.noempty, req.timestamp)
log.Warn(">>>>>>>>>>> worker: mainLoop->newWorkCh after commitNewWork")
case ev := <-w.chainSideCh: case ev := <-w.chainSideCh:
//log.Warn("from mainLoop chainSideCh")
if w.config.XDPoS == nil { if w.config.XDPoS == nil {
// Short circuit for duplicate side blocks // Short circuit for duplicate side blocks
if _, exist := w.localUncles[ev.Block.Hash()]; exist { if _, exist := w.localUncles[ev.Block.Hash()]; exist {
@ -476,7 +471,6 @@ func (w *worker) mainLoop() {
} }
case ev := <-w.txsCh: case ev := <-w.txsCh:
//log.Warn("from mainLoop txsCh")
// Apply transactions to the pending state if we're not mining. // Apply transactions to the pending state if we're not mining.
// //
// Note all transactions received may not be continuous with transactions // Note all transactions received may not be continuous with transactions
@ -496,10 +490,8 @@ func (w *worker) mainLoop() {
w.commitTransactions(txset, specialTxs, coinbase, nil) w.commitTransactions(txset, specialTxs, coinbase, nil)
w.updateSnapshot() w.updateSnapshot()
} else { } else {
fmt.Println("from mainLoop txsCh")
// If we're mining, but nothing is being processed, wake on new transactions // If we're mining, but nothing is being processed, wake on new transactions
if w.config.XDPoS != nil && w.config.XDPoS.Period == 0 { if w.config.XDPoS != nil && w.config.XDPoS.Period == 0 {
fmt.Println("from mainLoop txsCh 1")
w.commitNewWork(nil, false, time.Now().Unix()) w.commitNewWork(nil, false, time.Now().Unix())
} }
} }
@ -507,16 +499,12 @@ func (w *worker) mainLoop() {
// System stopped // System stopped
case <-w.exitCh: case <-w.exitCh:
fmt.Println("from mainLoop exitCh")
return return
case <-w.txsSub.Err(): case <-w.txsSub.Err():
fmt.Println("from mainLoop txsSub.Err()")
return return
case <-w.chainHeadSub.Err(): case <-w.chainHeadSub.Err():
fmt.Println("from mainLoop chainHeadSub.Err()")
return return
case <-w.chainSideSub.Err(): case <-w.chainSideSub.Err():
fmt.Println("from mainLoop chainSideSub.Err()")
return return
} }
} }
@ -540,7 +528,6 @@ func (w *worker) taskLoop() {
for { for {
select { select {
case task := <-w.taskCh: case task := <-w.taskCh:
log.Warn(">>>>>>>>>>> worker: taskLoop taskCh", "hash", task.block.Header().Hash())
if w.newTaskHook != nil { if w.newTaskHook != nil {
w.newTaskHook(task) w.newTaskHook(task)
} }
@ -563,9 +550,7 @@ func (w *worker) taskLoop() {
if err := w.engine.Seal(w.chain, task.block, w.resultCh, stopCh); err != nil { if err := w.engine.Seal(w.chain, task.block, w.resultCh, stopCh); err != nil {
log.Warn("Block sealing failed", "err", err) log.Warn("Block sealing failed", "err", err)
} }
log.Warn(">>>>>>>>>>> worker: taskLoop end", "hash", task.block.Header().Hash())
case <-w.exitCh: case <-w.exitCh:
log.Warn(">>>>>>>>>>> worker: taskLoop exitCh")
interrupt() interrupt()
return return
} }
@ -639,12 +624,10 @@ func (w *worker) resultLoop() {
if w.config.XDPoS != nil { if w.config.XDPoS != nil {
// epoch block // epoch block
if (block.NumberU64() % w.config.XDPoS.Epoch) == 0 { if (block.NumberU64() % w.config.XDPoS.Epoch) == 0 {
//log.Warn("push checkpoint channel in worker")
core.CheckpointCh <- 1 core.CheckpointCh <- 1
} }
// prepare set of masternodes for the next epoch // prepare set of masternodes for the next epoch
if (block.NumberU64() % w.config.XDPoS.Epoch) == (w.config.XDPoS.Epoch - w.config.XDPoS.Gap) { if (block.NumberU64() % w.config.XDPoS.Epoch) == (w.config.XDPoS.Epoch - w.config.XDPoS.Gap) {
//log.Warn("UpdateM1() worker")
err := w.chain.UpdateM1() err := w.chain.UpdateM1()
if err != nil { if err != nil {
log.Error("Error when update masternodes set. Stopping node", "err", err) log.Error("Error when update masternodes set. Stopping node", "err", err)
@ -982,15 +965,12 @@ func (w *worker) commitNewWork(interrupt *int32, noempty bool, timestamp int64)
parent := w.chain.CurrentBlock() parent := w.chain.CurrentBlock()
var signers map[common.Address]struct{} var signers map[common.Address]struct{}
if parent.Hash().Hex() == w.lastParentBlockCommit { if parent.Hash().Hex() == w.lastParentBlockCommit {
log.Warn(">>>>>>>>>>> worker: lastParentBlockCommit mismatch")
return return
} }
if !w.announceTxs && !w.isRunning() { if !w.announceTxs && !w.isRunning() {
log.Warn(">>>>>>>>>>> worker: commitNewWork not running")
return return
} }
log.Warn(">>>>>>>>>>> worker: commitNewWork start")
// Only try to commit new work if we are mining // Only try to commit new work if we are mining
if w.isRunning() { if w.isRunning() {
// check if we are right after parent's coinbase in the list // check if we are right after parent's coinbase in the list
@ -1000,11 +980,11 @@ func (w *worker) commitNewWork(interrupt *int32, noempty bool, timestamp int64)
c := w.engine.(*XDPoS.XDPoS) c := w.engine.(*XDPoS.XDPoS)
len, preIndex, curIndex, ok, err := c.YourTurn(w.chain, parent.Header(), w.coinbase) len, preIndex, curIndex, ok, err := c.YourTurn(w.chain, parent.Header(), w.coinbase)
if err != nil { if err != nil {
log.Warn(">>>>>>>>>>> worker: Failed when trying to commit new work", "err", err) log.Warn("Failed when trying to commit new work", "err", err)
return return
} }
if !ok { if !ok {
log.Info(">>>>>>>>>>> worker: Not my turn to commit block. Waiting...") log.Info("Not my turn to commit block. Waiting...")
// in case some nodes are down // in case some nodes are down
if preIndex == -1 { if preIndex == -1 {
// first block // first block
@ -1021,12 +1001,12 @@ func (w *worker) commitNewWork(interrupt *int32, noempty bool, timestamp int64)
if uint64(h) >= nearest { if uint64(h) >= nearest {
gap = waitPeriodCheckpoint * int64(h) gap = waitPeriodCheckpoint * int64(h)
} }
log.Info(">>>>>>>>>>> worker: Distance from the parent block", "seconds", gap, "hops", h) log.Info("Distance from the parent block", "seconds", gap, "hops", h)
waitedTime := time.Now().Unix() - int64(parent.Header().Time) waitedTime := time.Now().Unix() - int64(parent.Header().Time)
if gap > waitedTime { if gap > waitedTime {
return return
} }
log.Info(">>>>>>>>>>> worker: Wait enough. It's my turn", "waited seconds", waitedTime) log.Info("Wait enough. It's my turn", "waited seconds", waitedTime)
} }
} }
} }
@ -1037,7 +1017,7 @@ func (w *worker) commitNewWork(interrupt *int32, noempty bool, timestamp int64)
// this will ensure we're not going off too far in the future // this will ensure we're not going off too far in the future
if now := time.Now().Unix(); timestamp > now+1 { if now := time.Now().Unix(); timestamp > now+1 {
wait := time.Duration(timestamp-now) * time.Second wait := time.Duration(timestamp-now) * time.Second
log.Info(">>>>>>>>>>> worker: Mining too far in the future", "wait", common.PrettyDuration(wait)) log.Info("Mining too far in the future", "wait", common.PrettyDuration(wait))
time.Sleep(wait) time.Sleep(wait)
} }
@ -1052,13 +1032,13 @@ func (w *worker) commitNewWork(interrupt *int32, noempty bool, timestamp int64)
// Only set the coinbase if our consensus engine is running (avoid spurious block rewards) // Only set the coinbase if our consensus engine is running (avoid spurious block rewards)
if w.isRunning() { if w.isRunning() {
if w.coinbase == (common.Address{}) { if w.coinbase == (common.Address{}) {
log.Error(">>>>>>>>>>> worker: Refusing to mine without etherbase") log.Error("Refusing to mine without etherbase")
return return
} }
header.Coinbase = w.coinbase header.Coinbase = w.coinbase
} }
if err := w.engine.Prepare(w.chain, header); err != nil { if err := w.engine.Prepare(w.chain, header); err != nil {
log.Error(">>>>>>>>>>> worker: Failed to prepare header for new block", "err", err) log.Error("Failed to prepare header for new block", "err", err)
return return
} }
// If we are care about TheDAO hard-fork check whether to override the extra-data or not // If we are care about TheDAO hard-fork check whether to override the extra-data or not
@ -1074,11 +1054,10 @@ func (w *worker) commitNewWork(interrupt *int32, noempty bool, timestamp int64)
} }
} }
} }
log.Warn(">>>>>>>>>>> worker: make current")
// Could potentially happen if starting to mine in an odd state. // Could potentially happen if starting to mine in an odd state.
err := w.makeCurrent(parent, header) err := w.makeCurrent(parent, header)
if err != nil { if err != nil {
log.Error(">>>>>>>>>>> worker: Failed to create mining context", "err", err) log.Error("Failed to create mining context", "err", err)
return return
} }
// Create the current work task and check any fork transitions needed // Create the current work task and check any fork transitions needed
@ -1130,7 +1109,7 @@ func (w *worker) commitNewWork(interrupt *int32, noempty bool, timestamp int64)
// Fill the block with all available pending transactions. // Fill the block with all available pending transactions.
pending, err := w.eth.TxPool().Pending() pending, err := w.eth.TxPool().Pending()
if err != nil { if err != nil {
log.Error(">>>>>>>>>>> worker: Failed to fetch pending transactions", "err", err) log.Error("Failed to fetch pending transactions", "err", err)
return return
} }
// Short circuit if there is no available pending transactions // Short circuit if there is no available pending transactions
@ -1147,7 +1126,6 @@ func (w *worker) commitNewWork(interrupt *int32, noempty bool, timestamp int64)
} }
} }
} }
log.Warn(">>>>>>>>>>> worker: commit transactions", "local", len(localTxs), "remote", len(remoteTxs))
if len(localTxs) > 0 { if len(localTxs) > 0 {
txs, specialTxs := types.NewTransactionsByPriceAndNonce(w.current.signer, localTxs, signers) txs, specialTxs := types.NewTransactionsByPriceAndNonce(w.current.signer, localTxs, signers)
if w.commitTransactions(txs, specialTxs, w.coinbase, interrupt) { if w.commitTransactions(txs, specialTxs, w.coinbase, interrupt) {
@ -1166,7 +1144,6 @@ func (w *worker) commitNewWork(interrupt *int32, noempty bool, timestamp int64)
// commit runs any post-transaction state modifications, assembles the final block // commit runs any post-transaction state modifications, assembles the final block
// and commits new work if consensus engine is running. // and commits new work if consensus engine is running.
func (w *worker) commit(uncles []*types.Header, interval func(), update bool, start time.Time) error { func (w *worker) commit(uncles []*types.Header, interval func(), update bool, start time.Time) error {
log.Warn(">>>>>>>>>>> worker: commit")
// Deep copy receipts here to avoid interaction between different tasks. // Deep copy receipts here to avoid interaction between different tasks.
receipts := make([]*types.Receipt, len(w.current.receipts)) receipts := make([]*types.Receipt, len(w.current.receipts))
for i, l := range w.current.receipts { for i, l := range w.current.receipts {
@ -1176,14 +1153,12 @@ func (w *worker) commit(uncles []*types.Header, interval func(), update bool, st
s := w.current.state.Copy() s := w.current.state.Copy()
block, err := w.engine.Finalize(w.chain, w.current.header, s, w.current.txs, uncles, w.current.receipts) block, err := w.engine.Finalize(w.chain, w.current.header, s, w.current.txs, uncles, w.current.receipts)
if err != nil { if err != nil {
log.Warn(">>>>>>>>>>> worker: finalization error", "error", err.Error())
return err return err
} }
if w.isRunning() { if w.isRunning() {
if interval != nil { if interval != nil {
interval() interval()
} }
log.Warn(">>>>>>>>>>> worker: create a task", "hash", block.Header().Hash())
select { select {
case w.taskCh <- &task{receipts: receipts, state: s, block: block, createdAt: time.Now()}: case w.taskCh <- &task{receipts: receipts, state: s, block: block, createdAt: time.Now()}:
w.unconfirmed.Shift(block.NumberU64() - 1) w.unconfirmed.Shift(block.NumberU64() - 1)
@ -1205,6 +1180,5 @@ func (w *worker) commit(uncles []*types.Header, interval func(), update bool, st
if update { if update {
w.updateSnapshot() w.updateSnapshot()
} }
log.Warn(">>>>>>>>>>> worker: commit end")
return nil return nil
} }

39
miner/worker_test.go
View file

@ -21,6 +21,7 @@ import (
"testing" "testing"
"time" "time"
"github.com/ethereum/go-ethereum/accounts"
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/consensus" "github.com/ethereum/go-ethereum/consensus"
"github.com/ethereum/go-ethereum/consensus/clique" "github.com/ethereum/go-ethereum/consensus/clique"
@ -124,7 +125,9 @@ func newTestWorkerBackend(t *testing.T, chainConfig *params.ChainConfig, engine
} }
} }
func (b *testWorkerBackend) AccountManager() *accounts.Manager { return accounts.NewManager() }
func (b *testWorkerBackend) BlockChain() *core.BlockChain { return b.chain } func (b *testWorkerBackend) BlockChain() *core.BlockChain { return b.chain }
func (b *testWorkerBackend) ChainDb() ethdb.Database { return b.db }
func (b *testWorkerBackend) TxPool() *core.TxPool { return b.txPool } func (b *testWorkerBackend) TxPool() *core.TxPool { return b.txPool }
func (b *testWorkerBackend) PostChainEvents(events []interface{}) { func (b *testWorkerBackend) PostChainEvents(events []interface{}) {
b.chain.PostChainEvents(events, nil) b.chain.PostChainEvents(events, nil)
@ -133,7 +136,7 @@ func (b *testWorkerBackend) PostChainEvents(events []interface{}) {
func newTestWorker(t *testing.T, chainConfig *params.ChainConfig, engine consensus.Engine, blocks int) (*worker, *testWorkerBackend) { func newTestWorker(t *testing.T, chainConfig *params.ChainConfig, engine consensus.Engine, blocks int) (*worker, *testWorkerBackend) {
backend := newTestWorkerBackend(t, chainConfig, engine, blocks) backend := newTestWorkerBackend(t, chainConfig, engine, blocks)
backend.txPool.AddLocals(pendingTxs) backend.txPool.AddLocals(pendingTxs)
w := newWorker(chainConfig, engine, backend, new(event.TypeMux), time.Second, params.GenesisGasLimit, params.GenesisGasLimit, nil) w := newWorker(chainConfig, engine, backend, new(event.TypeMux), time.Second, params.GenesisGasLimit, params.GenesisGasLimit, nil, true)
w.setEtherbase(testBankAddress) w.setEtherbase(testBankAddress)
return w, backend return w, backend
} }
@ -157,25 +160,25 @@ func testPendingStateAndBlock(t *testing.T, chainConfig *params.ChainConfig, eng
if block.NumberU64() != 1 { if block.NumberU64() != 1 {
t.Errorf("block number mismatch: have %d, want %d", block.NumberU64(), 1) t.Errorf("block number mismatch: have %d, want %d", block.NumberU64(), 1)
} }
if balance := state.GetBalance(testUserAddress); balance.Cmp(big.NewInt(1000)) != 0 { if balance := state.GetBalance(testUserAddress); balance.Cmp(big.NewInt(0)) != 0 {
t.Errorf("account balance mismatch: have %d, want %d", balance, 1000) t.Errorf("account balance mismatch: have %d, want %d", balance, 0)
} }
b.txPool.AddLocals(newTxs) b.txPool.AddLocals(newTxs)
// Ensure the new tx events has been processed // Ensure the new tx events has been processed
time.Sleep(100 * time.Millisecond) time.Sleep(100 * time.Millisecond)
block, state = w.pending() block, state = w.pending()
if balance := state.GetBalance(testUserAddress); balance.Cmp(big.NewInt(2000)) != 0 { if balance := state.GetBalance(testUserAddress); balance.Cmp(big.NewInt(0)) != 0 {
t.Errorf("account balance mismatch: have %d, want %d", balance, 2000) t.Errorf("account balance mismatch: have %d, want %d", balance, 0)
} }
} }
func TestEmptyWorkEthash(t *testing.T) { //func TestEmptyWorkEthash(t *testing.T) {
testEmptyWork(t, ethashChainConfig, ethash.NewFaker()) // testEmptyWork(t, ethashChainConfig, ethash.NewFaker())
} //}
func TestEmptyWorkClique(t *testing.T) { //func TestEmptyWorkClique(t *testing.T) {
testEmptyWork(t, cliqueChainConfig, clique.New(cliqueChainConfig.Clique, ethdb.NewMemDatabase())) // testEmptyWork(t, cliqueChainConfig, clique.New(cliqueChainConfig.Clique, ethdb.NewMemDatabase()))
} //}
func testEmptyWork(t *testing.T, chainConfig *params.ChainConfig, engine consensus.Engine) { func testEmptyWork(t *testing.T, chainConfig *params.ChainConfig, engine consensus.Engine) {
defer engine.Close() defer engine.Close()
@ -286,13 +289,13 @@ func TestStreamUncleBlock(t *testing.T) {
} }
} }
func TestRegenerateMiningBlockEthash(t *testing.T) { //func TestRegenerateMiningBlockEthash(t *testing.T) {
testRegenerateMiningBlock(t, ethashChainConfig, ethash.NewFaker()) // testRegenerateMiningBlock(t, ethashChainConfig, ethash.NewFaker())
} //}
//
func TestRegenerateMiningBlockClique(t *testing.T) { //func TestRegenerateMiningBlockClique(t *testing.T) {
testRegenerateMiningBlock(t, cliqueChainConfig, clique.New(cliqueChainConfig.Clique, ethdb.NewMemDatabase())) // testRegenerateMiningBlock(t, cliqueChainConfig, clique.New(cliqueChainConfig.Clique, ethdb.NewMemDatabase()))
} //}
func testRegenerateMiningBlock(t *testing.T, chainConfig *params.ChainConfig, engine consensus.Engine) { func testRegenerateMiningBlock(t *testing.T, chainConfig *params.ChainConfig, engine consensus.Engine) {
defer engine.Close() defer engine.Close()

4
p2p/discv5/node_test.go
View file

@ -72,7 +72,7 @@ var parseNodeTests = []struct {
}, },
{ {
rawurl: "enode://1dd9d65c4552b5eb43d5ad55a2ee3f56c6cbc1c64a5c8d659f51fcd51bace24351232b8d7821617d2b29b54b81cdefb9b3e9c37d7fd5f63270bcc9e1a6f6a439@127.0.0.1:foo", rawurl: "enode://1dd9d65c4552b5eb43d5ad55a2ee3f56c6cbc1c64a5c8d659f51fcd51bace24351232b8d7821617d2b29b54b81cdefb9b3e9c37d7fd5f63270bcc9e1a6f6a439@127.0.0.1:foo",
wantError: `invalid port`, wantError: `parse "enode://1dd9d65c4552b5eb43d5ad55a2ee3f56c6cbc1c64a5c8d659f51fcd51bace24351232b8d7821617d2b29b54b81cdefb9b3e9c37d7fd5f63270bcc9e1a6f6a439@127.0.0.1:foo": invalid port ":foo" after host`,
}, },
{ {
rawurl: "enode://1dd9d65c4552b5eb43d5ad55a2ee3f56c6cbc1c64a5c8d659f51fcd51bace24351232b8d7821617d2b29b54b81cdefb9b3e9c37d7fd5f63270bcc9e1a6f6a439@127.0.0.1:3?discport=foo", rawurl: "enode://1dd9d65c4552b5eb43d5ad55a2ee3f56c6cbc1c64a5c8d659f51fcd51bace24351232b8d7821617d2b29b54b81cdefb9b3e9c37d7fd5f63270bcc9e1a6f6a439@127.0.0.1:3?discport=foo",
@ -141,7 +141,7 @@ var parseNodeTests = []struct {
{ {
// This test checks that errors from url.Parse are handled. // This test checks that errors from url.Parse are handled.
rawurl: "://foo", rawurl: "://foo",
wantError: `parse ://foo: missing protocol scheme`, wantError: `parse "://foo": missing protocol scheme`,
}, },
} }

4
p2p/enode/urlv4_test.go
View file

@ -47,7 +47,7 @@ var parseNodeTests = []struct {
}, },
{ {
rawurl: "enode://1dd9d65c4552b5eb43d5ad55a2ee3f56c6cbc1c64a5c8d659f51fcd51bace24351232b8d7821617d2b29b54b81cdefb9b3e9c37d7fd5f63270bcc9e1a6f6a439@127.0.0.1:foo", rawurl: "enode://1dd9d65c4552b5eb43d5ad55a2ee3f56c6cbc1c64a5c8d659f51fcd51bace24351232b8d7821617d2b29b54b81cdefb9b3e9c37d7fd5f63270bcc9e1a6f6a439@127.0.0.1:foo",
wantError: `invalid port`, wantError: `parse "enode://1dd9d65c4552b5eb43d5ad55a2ee3f56c6cbc1c64a5c8d659f51fcd51bace24351232b8d7821617d2b29b54b81cdefb9b3e9c37d7fd5f63270bcc9e1a6f6a439@127.0.0.1:foo": invalid port ":foo" after host`,
}, },
{ {
rawurl: "enode://1dd9d65c4552b5eb43d5ad55a2ee3f56c6cbc1c64a5c8d659f51fcd51bace24351232b8d7821617d2b29b54b81cdefb9b3e9c37d7fd5f63270bcc9e1a6f6a439@127.0.0.1:3?discport=foo", rawurl: "enode://1dd9d65c4552b5eb43d5ad55a2ee3f56c6cbc1c64a5c8d659f51fcd51bace24351232b8d7821617d2b29b54b81cdefb9b3e9c37d7fd5f63270bcc9e1a6f6a439@127.0.0.1:3?discport=foo",
@ -116,7 +116,7 @@ var parseNodeTests = []struct {
{ {
// This test checks that errors from url.Parse are handled. // This test checks that errors from url.Parse are handled.
rawurl: "://foo", rawurl: "://foo",
wantError: `parse ://foo: missing protocol scheme`, wantError: `parse "://foo": missing protocol scheme`,
}, },
} }

2
params/version.go
View file

@ -24,7 +24,7 @@ const (
VersionMajor = 1 // Major version component of the current release VersionMajor = 1 // Major version component of the current release
VersionMinor = 1 // Minor version component of the current release VersionMinor = 1 // Minor version component of the current release
VersionPatch = 1827 // Patch version component of the current release VersionPatch = 1827 // Patch version component of the current release
VersionMeta = "stable" // Version metadata to append to the version string VersionMeta = "unstable" // Version metadata to append to the version string
) )
// Version holds the textual version string. // Version holds the textual version string.