“GheisMohammadi”
2 years ago
parent
4a69714c37
commit
40a7363519
@ -1,31 +0,0 @@ |
||||
package synchronize |
||||
|
||||
import ( |
||||
"github.com/harmony-one/harmony/core" |
||||
"github.com/harmony-one/harmony/hmy/downloader" |
||||
"github.com/harmony-one/harmony/p2p" |
||||
) |
||||
|
||||
// Service is simply a adapter of Downloaders, which support block synchronization
|
||||
type Service struct { |
||||
Downloaders *downloader.Downloaders |
||||
} |
||||
|
||||
// NewService creates the a new downloader service
|
||||
func NewService(host p2p.Host, bcs []core.BlockChain, config downloader.Config) *Service { |
||||
return &Service{ |
||||
Downloaders: downloader.NewDownloaders(host, bcs, config), |
||||
} |
||||
} |
||||
|
||||
// Start start the service
|
||||
func (s *Service) Start() error { |
||||
s.Downloaders.Start() |
||||
return nil |
||||
} |
||||
|
||||
// Stop stop the service
|
||||
func (s *Service) Stop() error { |
||||
s.Downloaders.Close() |
||||
return nil |
||||
} |
||||
@ -1,32 +0,0 @@ |
||||
package downloader |
||||
|
||||
import ( |
||||
"context" |
||||
|
||||
"github.com/ethereum/go-ethereum/common" |
||||
"github.com/ethereum/go-ethereum/event" |
||||
"github.com/harmony-one/harmony/consensus/engine" |
||||
"github.com/harmony-one/harmony/core/types" |
||||
"github.com/harmony-one/harmony/p2p/stream/common/streammanager" |
||||
syncproto "github.com/harmony-one/harmony/p2p/stream/protocols/sync" |
||||
sttypes "github.com/harmony-one/harmony/p2p/stream/types" |
||||
) |
||||
|
||||
type syncProtocol interface { |
||||
GetCurrentBlockNumber(ctx context.Context, opts ...syncproto.Option) (uint64, sttypes.StreamID, error) |
||||
GetBlocksByNumber(ctx context.Context, bns []uint64, opts ...syncproto.Option) ([]*types.Block, sttypes.StreamID, error) |
||||
GetBlockHashes(ctx context.Context, bns []uint64, opts ...syncproto.Option) ([]common.Hash, sttypes.StreamID, error) |
||||
GetBlocksByHashes(ctx context.Context, hs []common.Hash, opts ...syncproto.Option) ([]*types.Block, sttypes.StreamID, error) |
||||
|
||||
RemoveStream(stID sttypes.StreamID) // If a stream delivers invalid data, remove the stream
|
||||
SubscribeAddStreamEvent(ch chan<- streammanager.EvtStreamAdded) event.Subscription |
||||
NumStreams() int |
||||
} |
||||
|
||||
type blockChain interface { |
||||
engine.ChainReader |
||||
Engine() engine.Engine |
||||
|
||||
InsertChain(chain types.Blocks, verifyHeaders bool) (int, error) |
||||
WriteCommitSig(blockNum uint64, lastCommits []byte) error |
||||
} |
||||
@ -1,366 +0,0 @@ |
||||
package downloader |
||||
|
||||
import ( |
||||
"context" |
||||
"fmt" |
||||
"math/big" |
||||
"sync" |
||||
|
||||
"github.com/ethereum/go-ethereum/common" |
||||
"github.com/ethereum/go-ethereum/event" |
||||
|
||||
"github.com/harmony-one/harmony/block" |
||||
"github.com/harmony-one/harmony/consensus/engine" |
||||
"github.com/harmony-one/harmony/consensus/reward" |
||||
"github.com/harmony-one/harmony/core/state" |
||||
"github.com/harmony-one/harmony/core/types" |
||||
"github.com/harmony-one/harmony/crypto/bls" |
||||
"github.com/harmony-one/harmony/internal/params" |
||||
"github.com/harmony-one/harmony/p2p/stream/common/streammanager" |
||||
syncproto "github.com/harmony-one/harmony/p2p/stream/protocols/sync" |
||||
sttypes "github.com/harmony-one/harmony/p2p/stream/types" |
||||
"github.com/harmony-one/harmony/shard" |
||||
"github.com/harmony-one/harmony/staking/slash" |
||||
staking "github.com/harmony-one/harmony/staking/types" |
||||
) |
||||
|
||||
type testBlockChain struct { |
||||
curBN uint64 |
||||
insertErrHook func(bn uint64) error |
||||
lock sync.Mutex |
||||
} |
||||
|
||||
func newTestBlockChain(curBN uint64, insertErrHook func(bn uint64) error) *testBlockChain { |
||||
return &testBlockChain{ |
||||
curBN: curBN, |
||||
insertErrHook: insertErrHook, |
||||
} |
||||
} |
||||
|
||||
func (bc *testBlockChain) CurrentBlock() *types.Block { |
||||
bc.lock.Lock() |
||||
defer bc.lock.Unlock() |
||||
|
||||
return makeTestBlock(bc.curBN) |
||||
} |
||||
|
||||
func (bc *testBlockChain) CurrentHeader() *block.Header { |
||||
bc.lock.Lock() |
||||
defer bc.lock.Unlock() |
||||
|
||||
return makeTestBlock(bc.curBN).Header() |
||||
} |
||||
|
||||
func (bc *testBlockChain) currentBlockNumber() uint64 { |
||||
bc.lock.Lock() |
||||
defer bc.lock.Unlock() |
||||
|
||||
return bc.curBN |
||||
} |
||||
|
||||
func (bc *testBlockChain) InsertChain(chain types.Blocks, verifyHeaders bool) (int, error) { |
||||
bc.lock.Lock() |
||||
defer bc.lock.Unlock() |
||||
|
||||
for i, block := range chain { |
||||
if bc.insertErrHook != nil { |
||||
if err := bc.insertErrHook(block.NumberU64()); err != nil { |
||||
return i, err |
||||
} |
||||
} |
||||
if block.NumberU64() <= bc.curBN { |
||||
continue |
||||
} |
||||
if block.NumberU64() != bc.curBN+1 { |
||||
return i, fmt.Errorf("not expected block number: %v / %v", block.NumberU64(), bc.curBN+1) |
||||
} |
||||
bc.curBN++ |
||||
} |
||||
return len(chain), nil |
||||
} |
||||
|
||||
func (bc *testBlockChain) changeBlockNumber(val uint64) { |
||||
bc.lock.Lock() |
||||
defer bc.lock.Unlock() |
||||
|
||||
bc.curBN = val |
||||
} |
||||
|
||||
func (bc *testBlockChain) ShardID() uint32 { return 0 } |
||||
func (bc *testBlockChain) ReadShardState(epoch *big.Int) (*shard.State, error) { return nil, nil } |
||||
func (bc *testBlockChain) Config() *params.ChainConfig { return nil } |
||||
func (bc *testBlockChain) WriteCommitSig(blockNum uint64, lastCommits []byte) error { return nil } |
||||
func (bc *testBlockChain) GetHeader(hash common.Hash, number uint64) *block.Header { return nil } |
||||
func (bc *testBlockChain) GetHeaderByNumber(number uint64) *block.Header { return nil } |
||||
func (bc *testBlockChain) GetHeaderByHash(hash common.Hash) *block.Header { return nil } |
||||
func (bc *testBlockChain) GetBlock(hash common.Hash, number uint64) *types.Block { return nil } |
||||
func (bc *testBlockChain) ReadValidatorList() ([]common.Address, error) { return nil, nil } |
||||
func (bc *testBlockChain) ReadCommitSig(blockNum uint64) ([]byte, error) { return nil, nil } |
||||
func (bc *testBlockChain) ReadBlockRewardAccumulator(uint64) (*big.Int, error) { return nil, nil } |
||||
func (bc *testBlockChain) ValidatorCandidates() []common.Address { return nil } |
||||
func (bc *testBlockChain) Engine() engine.Engine { return &dummyEngine{} } |
||||
func (cr *testBlockChain) ReadValidatorInformationAtState( |
||||
addr common.Address, state *state.DB, |
||||
) (*staking.ValidatorWrapper, error) { |
||||
return nil, nil |
||||
} |
||||
func (cr *testBlockChain) StateAt(root common.Hash) (*state.DB, error) { |
||||
return nil, nil |
||||
} |
||||
func (bc *testBlockChain) ReadValidatorInformation(addr common.Address) (*staking.ValidatorWrapper, error) { |
||||
return nil, nil |
||||
} |
||||
func (bc *testBlockChain) ReadValidatorSnapshot(addr common.Address) (*staking.ValidatorSnapshot, error) { |
||||
return nil, nil |
||||
} |
||||
func (bc *testBlockChain) ReadValidatorSnapshotAtEpoch(epoch *big.Int, addr common.Address) (*staking.ValidatorSnapshot, error) { |
||||
return nil, nil |
||||
} |
||||
func (bc *testBlockChain) ReadValidatorStats(addr common.Address) (*staking.ValidatorStats, error) { |
||||
return nil, nil |
||||
} |
||||
func (bc *testBlockChain) SuperCommitteeForNextEpoch(beacon engine.ChainReader, header *block.Header, isVerify bool) (*shard.State, error) { |
||||
return nil, nil |
||||
} |
||||
|
||||
type dummyEngine struct{} |
||||
|
||||
func (e *dummyEngine) VerifyHeader(engine.ChainReader, *block.Header, bool) error { |
||||
return nil |
||||
} |
||||
func (e *dummyEngine) VerifyHeaderSignature(engine.ChainReader, *block.Header, bls.SerializedSignature, []byte) error { |
||||
return nil |
||||
} |
||||
func (e *dummyEngine) VerifyCrossLink(engine.ChainReader, types.CrossLink) error { |
||||
return nil |
||||
} |
||||
func (e *dummyEngine) VerifyVRF(chain engine.ChainReader, header *block.Header) error { |
||||
return nil |
||||
} |
||||
func (e *dummyEngine) VerifyHeaders(engine.ChainReader, []*block.Header, []bool) (chan<- struct{}, <-chan error) { |
||||
return nil, nil |
||||
} |
||||
func (e *dummyEngine) VerifySeal(engine.ChainReader, *block.Header) error { return nil } |
||||
func (e *dummyEngine) VerifyShardState(engine.ChainReader, engine.ChainReader, *block.Header) error { |
||||
return nil |
||||
} |
||||
func (e *dummyEngine) Beaconchain() engine.ChainReader { return nil } |
||||
func (e *dummyEngine) SetBeaconchain(engine.ChainReader) {} |
||||
func (e *dummyEngine) Finalize( |
||||
chain engine.ChainReader, beacon engine.ChainReader, header *block.Header, |
||||
state *state.DB, txs []*types.Transaction, |
||||
receipts []*types.Receipt, outcxs []*types.CXReceipt, |
||||
incxs []*types.CXReceiptsProof, stks staking.StakingTransactions, |
||||
doubleSigners slash.Records, sigsReady chan bool, viewID func() uint64, |
||||
) (*types.Block, reward.Reader, error) { |
||||
return nil, nil, nil |
||||
} |
||||
|
||||
type testInsertHelper struct { |
||||
bc *testBlockChain |
||||
} |
||||
|
||||
func (ch *testInsertHelper) verifyAndInsertBlock(block *types.Block) error { |
||||
_, err := ch.bc.InsertChain(types.Blocks{block}, true) |
||||
return err |
||||
} |
||||
func (ch *testInsertHelper) verifyAndInsertBlocks(blocks types.Blocks) (int, error) { |
||||
return ch.bc.InsertChain(blocks, true) |
||||
} |
||||
|
||||
const ( |
||||
initStreamNum = 32 |
||||
minStreamNum = 16 |
||||
) |
||||
|
||||
type testSyncProtocol struct { |
||||
streamIDs []sttypes.StreamID |
||||
remoteChain *testBlockChain |
||||
requestErrHook func(uint64) error |
||||
|
||||
curIndex int |
||||
numStreams int |
||||
lock sync.Mutex |
||||
} |
||||
|
||||
func newTestSyncProtocol(targetBN uint64, numStreams int, requestErrHook func(uint64) error) *testSyncProtocol { |
||||
return &testSyncProtocol{ |
||||
streamIDs: makeStreamIDs(numStreams), |
||||
remoteChain: newTestBlockChain(targetBN, nil), |
||||
requestErrHook: requestErrHook, |
||||
curIndex: 0, |
||||
numStreams: numStreams, |
||||
} |
||||
} |
||||
|
||||
func (sp *testSyncProtocol) GetCurrentBlockNumber(ctx context.Context, opts ...syncproto.Option) (uint64, sttypes.StreamID, error) { |
||||
sp.lock.Lock() |
||||
defer sp.lock.Unlock() |
||||
|
||||
bn := sp.remoteChain.currentBlockNumber() |
||||
|
||||
return bn, sp.nextStreamID(), nil |
||||
} |
||||
|
||||
func (sp *testSyncProtocol) GetBlocksByNumber(ctx context.Context, bns []uint64, opts ...syncproto.Option) ([]*types.Block, sttypes.StreamID, error) { |
||||
sp.lock.Lock() |
||||
defer sp.lock.Unlock() |
||||
|
||||
res := make([]*types.Block, 0, len(bns)) |
||||
for _, bn := range bns { |
||||
if sp.requestErrHook != nil { |
||||
if err := sp.requestErrHook(bn); err != nil { |
||||
return nil, sp.nextStreamID(), err |
||||
} |
||||
} |
||||
if bn > sp.remoteChain.currentBlockNumber() { |
||||
res = append(res, nil) |
||||
} else { |
||||
res = append(res, makeTestBlock(bn)) |
||||
} |
||||
} |
||||
return res, sp.nextStreamID(), nil |
||||
} |
||||
|
||||
func (sp *testSyncProtocol) GetBlockHashes(ctx context.Context, bns []uint64, opts ...syncproto.Option) ([]common.Hash, sttypes.StreamID, error) { |
||||
sp.lock.Lock() |
||||
defer sp.lock.Unlock() |
||||
|
||||
res := make([]common.Hash, 0, len(bns)) |
||||
for _, bn := range bns { |
||||
if sp.requestErrHook != nil { |
||||
if err := sp.requestErrHook(bn); err != nil { |
||||
return nil, sp.nextStreamID(), err |
||||
} |
||||
} |
||||
if bn > sp.remoteChain.currentBlockNumber() { |
||||
res = append(res, emptyHash) |
||||
} else { |
||||
res = append(res, makeTestBlockHash(bn)) |
||||
} |
||||
} |
||||
return res, sp.nextStreamID(), nil |
||||
} |
||||
|
||||
func (sp *testSyncProtocol) GetBlocksByHashes(ctx context.Context, hs []common.Hash, opts ...syncproto.Option) ([]*types.Block, sttypes.StreamID, error) { |
||||
sp.lock.Lock() |
||||
defer sp.lock.Unlock() |
||||
|
||||
res := make([]*types.Block, 0, len(hs)) |
||||
for _, h := range hs { |
||||
bn := testHashToNumber(h) |
||||
if sp.requestErrHook != nil { |
||||
if err := sp.requestErrHook(bn); err != nil { |
||||
return nil, sp.nextStreamID(), err |
||||
} |
||||
} |
||||
if bn > sp.remoteChain.currentBlockNumber() { |
||||
res = append(res, nil) |
||||
} else { |
||||
res = append(res, makeTestBlock(bn)) |
||||
} |
||||
} |
||||
return res, sp.nextStreamID(), nil |
||||
} |
||||
|
||||
func (sp *testSyncProtocol) RemoveStream(target sttypes.StreamID) { |
||||
sp.lock.Lock() |
||||
defer sp.lock.Unlock() |
||||
|
||||
for i, stid := range sp.streamIDs { |
||||
if stid == target { |
||||
if i == len(sp.streamIDs)-1 { |
||||
sp.streamIDs = sp.streamIDs[:i] |
||||
} else { |
||||
sp.streamIDs = append(sp.streamIDs[:i], sp.streamIDs[i+1:]...) |
||||
} |
||||
// mock discovery
|
||||
if len(sp.streamIDs) < minStreamNum { |
||||
sp.streamIDs = append(sp.streamIDs, makeStreamID(sp.numStreams)) |
||||
sp.numStreams++ |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
func (sp *testSyncProtocol) NumStreams() int { |
||||
sp.lock.Lock() |
||||
defer sp.lock.Unlock() |
||||
|
||||
return len(sp.streamIDs) |
||||
} |
||||
|
||||
func (sp *testSyncProtocol) SubscribeAddStreamEvent(ch chan<- streammanager.EvtStreamAdded) event.Subscription { |
||||
var evtFeed event.Feed |
||||
go func() { |
||||
sp.lock.Lock() |
||||
num := len(sp.streamIDs) |
||||
sp.lock.Unlock() |
||||
for i := 0; i != num; i++ { |
||||
evtFeed.Send(streammanager.EvtStreamAdded{Stream: nil}) |
||||
} |
||||
}() |
||||
return evtFeed.Subscribe(ch) |
||||
} |
||||
|
||||
// TODO: add with whitelist stuff
|
||||
func (sp *testSyncProtocol) nextStreamID() sttypes.StreamID { |
||||
if sp.curIndex >= len(sp.streamIDs) { |
||||
sp.curIndex = 0 |
||||
} |
||||
index := sp.curIndex |
||||
sp.curIndex++ |
||||
if sp.curIndex >= len(sp.streamIDs) { |
||||
sp.curIndex = 0 |
||||
} |
||||
return sp.streamIDs[index] |
||||
} |
||||
|
||||
func (sp *testSyncProtocol) changeBlockNumber(val uint64) { |
||||
sp.remoteChain.changeBlockNumber(val) |
||||
} |
||||
|
||||
func makeStreamIDs(size int) []sttypes.StreamID { |
||||
res := make([]sttypes.StreamID, 0, size) |
||||
for i := 0; i != size; i++ { |
||||
res = append(res, makeStreamID(i)) |
||||
} |
||||
return res |
||||
} |
||||
|
||||
func makeStreamID(index int) sttypes.StreamID { |
||||
return sttypes.StreamID(fmt.Sprintf("test stream %v", index)) |
||||
} |
||||
|
||||
var ( |
||||
hashNumberMap = map[common.Hash]uint64{} |
||||
computed uint64 |
||||
hashNumberLock sync.Mutex |
||||
) |
||||
|
||||
func testHashToNumber(h common.Hash) uint64 { |
||||
hashNumberLock.Lock() |
||||
defer hashNumberLock.Unlock() |
||||
|
||||
if h == emptyHash { |
||||
panic("not allowed") |
||||
} |
||||
if bn, ok := hashNumberMap[h]; ok { |
||||
return bn |
||||
} |
||||
for ; ; computed++ { |
||||
ch := makeTestBlockHash(computed) |
||||
hashNumberMap[ch] = computed |
||||
if ch == h { |
||||
return computed |
||||
} |
||||
} |
||||
} |
||||
|
||||
func testNumberToHashes(nums []uint64) []common.Hash { |
||||
hashes := make([]common.Hash, 0, len(nums)) |
||||
for _, num := range nums { |
||||
hashes = append(hashes, makeTestBlockHash(num)) |
||||
} |
||||
return hashes |
||||
} |
||||
@ -1,156 +0,0 @@ |
||||
package downloader |
||||
|
||||
import ( |
||||
"time" |
||||
|
||||
"github.com/harmony-one/harmony/core/types" |
||||
"github.com/harmony-one/harmony/internal/utils" |
||||
"github.com/rs/zerolog" |
||||
) |
||||
|
||||
// lastMileCache keeps the last 50 number blocks in memory cache
|
||||
const lastMileCap = 50 |
||||
|
||||
type ( |
||||
// beaconHelper is the helper for the beacon downloader. The beaconHelper is only started
|
||||
// when node is running on side chain, listening to beacon client pub-sub message and
|
||||
// insert the latest blocks to the beacon chain.
|
||||
beaconHelper struct { |
||||
bc blockChain |
||||
blockC <-chan *types.Block |
||||
// TODO: refactor this hook to consensus module. We'd better put it in
|
||||
// consensus module under a subscription.
|
||||
insertHook func() |
||||
|
||||
lastMileCache *blocksByNumber |
||||
insertC chan insertTask |
||||
closeC chan struct{} |
||||
logger zerolog.Logger |
||||
} |
||||
|
||||
insertTask struct { |
||||
doneC chan struct{} |
||||
} |
||||
) |
||||
|
||||
func newBeaconHelper(bc blockChain, blockC <-chan *types.Block, insertHook func()) *beaconHelper { |
||||
return &beaconHelper{ |
||||
bc: bc, |
||||
blockC: blockC, |
||||
insertHook: insertHook, |
||||
lastMileCache: newBlocksByNumber(lastMileCap), |
||||
insertC: make(chan insertTask, 1), |
||||
closeC: make(chan struct{}), |
||||
logger: utils.Logger().With(). |
||||
Str("module", "downloader"). |
||||
Str("sub-module", "beacon helper"). |
||||
Logger(), |
||||
} |
||||
} |
||||
|
||||
func (bh *beaconHelper) start() { |
||||
go bh.loop() |
||||
} |
||||
|
||||
func (bh *beaconHelper) close() { |
||||
close(bh.closeC) |
||||
} |
||||
|
||||
func (bh *beaconHelper) loop() { |
||||
t := time.NewTicker(10 * time.Second) |
||||
defer t.Stop() |
||||
for { |
||||
select { |
||||
case <-t.C: |
||||
bh.insertAsync() |
||||
|
||||
case b, ok := <-bh.blockC: |
||||
if !ok { |
||||
return // blockC closed. Node exited
|
||||
} |
||||
if b == nil { |
||||
continue |
||||
} |
||||
bh.lastMileCache.push(b) |
||||
bh.insertAsync() |
||||
|
||||
case it := <-bh.insertC: |
||||
inserted, bn, err := bh.insertLastMileBlocks() |
||||
numBlocksInsertedBeaconHelperCounter.Add(float64(inserted)) |
||||
if err != nil { |
||||
bh.logger.Warn().Err(err).Msg("insert last mile blocks error") |
||||
continue |
||||
} |
||||
bh.logger.Info().Int("inserted", inserted). |
||||
Uint64("end height", bn). |
||||
Uint32("shard", bh.bc.ShardID()). |
||||
Msg("insert last mile blocks") |
||||
|
||||
close(it.doneC) |
||||
|
||||
case <-bh.closeC: |
||||
return |
||||
} |
||||
} |
||||
} |
||||
|
||||
// insertSync triggers the insert last mile without blocking
|
||||
func (bh *beaconHelper) insertAsync() { |
||||
select { |
||||
case bh.insertC <- insertTask{ |
||||
doneC: make(chan struct{}), |
||||
}: |
||||
default: |
||||
} |
||||
} |
||||
|
||||
// insertSync triggers the insert last mile while blocking
|
||||
func (bh *beaconHelper) insertSync() { |
||||
task := insertTask{ |
||||
doneC: make(chan struct{}), |
||||
} |
||||
bh.insertC <- task |
||||
<-task.doneC |
||||
} |
||||
|
||||
func (bh *beaconHelper) insertLastMileBlocks() (inserted int, bn uint64, err error) { |
||||
bn = bh.bc.CurrentBlock().NumberU64() + 1 |
||||
for { |
||||
b := bh.getNextBlock(bn) |
||||
if b == nil { |
||||
bn-- |
||||
return |
||||
} |
||||
// TODO: Instruct the beacon helper to verify signatures. This may require some forks
|
||||
// in pub-sub message (add commit sigs in node.block.sync messages)
|
||||
if _, err = bh.bc.InsertChain(types.Blocks{b}, true); err != nil { |
||||
bn-- |
||||
return |
||||
} |
||||
bh.logger.Info().Uint64("number", b.NumberU64()).Msg("Inserted block from beacon pub-sub") |
||||
|
||||
if bh.insertHook != nil { |
||||
bh.insertHook() |
||||
} |
||||
inserted++ |
||||
bn++ |
||||
} |
||||
} |
||||
|
||||
func (bh *beaconHelper) getNextBlock(expBN uint64) *types.Block { |
||||
for bh.lastMileCache.len() > 0 { |
||||
b := bh.lastMileCache.pop() |
||||
if b == nil { |
||||
return nil |
||||
} |
||||
if b.NumberU64() < expBN { |
||||
continue |
||||
} |
||||
if b.NumberU64() > expBN { |
||||
bh.lastMileCache.push(b) |
||||
return nil |
||||
} |
||||
return b |
||||
} |
||||
return nil |
||||
} |
||||
@ -1,80 +0,0 @@ |
||||
package downloader |
||||
|
||||
import ( |
||||
"time" |
||||
|
||||
"github.com/harmony-one/harmony/core/types" |
||||
nodeconfig "github.com/harmony-one/harmony/internal/configs/node" |
||||
) |
||||
|
||||
const ( |
||||
numBlocksByNumPerRequest int = 10 // number of blocks for each request
|
||||
blocksPerInsert int = 50 // number of blocks for each insert batch
|
||||
|
||||
numBlockHashesPerRequest int = 20 // number of get block hashes for short range sync
|
||||
numBlocksByHashesUpperCap int = 10 // number of get blocks by hashes upper cap
|
||||
numBlocksByHashesLowerCap int = 3 // number of get blocks by hashes lower cap
|
||||
|
||||
lastMileThres int = 10 |
||||
|
||||
// soft cap of size in resultQueue. When the queue size is larger than this limit,
|
||||
// no more request will be assigned to workers to wait for InsertChain to finish.
|
||||
softQueueCap int = 100 |
||||
|
||||
// defaultConcurrency is the default settings for concurrency
|
||||
defaultConcurrency = 4 |
||||
|
||||
// shortRangeTimeout is the timeout for each short range sync, which allow short range sync
|
||||
// to restart automatically when stuck in `getBlockHashes`
|
||||
shortRangeTimeout = 1 * time.Minute |
||||
) |
||||
|
||||
type ( |
||||
// Config is the downloader config
|
||||
Config struct { |
||||
// Only run stream sync protocol as a server.
|
||||
// TODO: remove this when stream sync is fully up.
|
||||
ServerOnly bool |
||||
// use staged sync
|
||||
Staged bool |
||||
// parameters
|
||||
Network nodeconfig.NetworkType |
||||
Concurrency int // Number of concurrent sync requests
|
||||
MinStreams int // Minimum number of streams to do sync
|
||||
InitStreams int // Number of streams requirement for initial bootstrap
|
||||
|
||||
// stream manager config
|
||||
SmSoftLowCap int |
||||
SmHardLowCap int |
||||
SmHiCap int |
||||
SmDiscBatch int |
||||
|
||||
// config for beacon config
|
||||
BHConfig *BeaconHelperConfig |
||||
} |
||||
|
||||
// BeaconHelperConfig is the extra config used for beaconHelper which uses
|
||||
// pub-sub block message to do sync.
|
||||
BeaconHelperConfig struct { |
||||
BlockC <-chan *types.Block |
||||
InsertHook func() |
||||
} |
||||
) |
||||
|
||||
func (c *Config) fixValues() { |
||||
if c.Concurrency == 0 { |
||||
c.Concurrency = defaultConcurrency |
||||
} |
||||
if c.Concurrency > c.MinStreams { |
||||
c.MinStreams = c.Concurrency |
||||
} |
||||
if c.MinStreams > c.InitStreams { |
||||
c.InitStreams = c.MinStreams |
||||
} |
||||
if c.MinStreams > c.SmSoftLowCap { |
||||
c.SmSoftLowCap = c.MinStreams |
||||
} |
||||
if c.MinStreams > c.SmHardLowCap { |
||||
c.SmHardLowCap = c.MinStreams |
||||
} |
||||
} |
||||
@ -1,321 +0,0 @@ |
||||
package downloader |
||||
|
||||
import ( |
||||
"context" |
||||
"fmt" |
||||
"time" |
||||
|
||||
"github.com/ethereum/go-ethereum/event" |
||||
"github.com/pkg/errors" |
||||
"github.com/rs/zerolog" |
||||
|
||||
"github.com/harmony-one/harmony/core" |
||||
"github.com/harmony-one/harmony/core/types" |
||||
"github.com/harmony-one/harmony/crypto/bls" |
||||
"github.com/harmony-one/harmony/internal/chain" |
||||
nodeconfig "github.com/harmony-one/harmony/internal/configs/node" |
||||
"github.com/harmony-one/harmony/internal/utils" |
||||
"github.com/harmony-one/harmony/p2p" |
||||
"github.com/harmony-one/harmony/p2p/stream/common/streammanager" |
||||
"github.com/harmony-one/harmony/p2p/stream/protocols/sync" |
||||
) |
||||
|
||||
type ( |
||||
// Downloader is responsible for sync task of one shard
|
||||
Downloader struct { |
||||
bc blockChain |
||||
syncProtocol syncProtocol |
||||
bh *beaconHelper |
||||
|
||||
downloadC chan struct{} |
||||
closeC chan struct{} |
||||
ctx context.Context |
||||
cancel func() |
||||
|
||||
evtDownloadFinished event.Feed // channel for each download task finished
|
||||
evtDownloadFinishedSubscribed bool |
||||
evtDownloadStarted event.Feed // channel for each download has started
|
||||
evtDownloadStartedSubscribed bool |
||||
|
||||
status status |
||||
config Config |
||||
logger zerolog.Logger |
||||
} |
||||
) |
||||
|
||||
// NewDownloader creates a new downloader
|
||||
func NewDownloader(host p2p.Host, bc core.BlockChain, isBeaconNode bool, config Config) *Downloader { |
||||
config.fixValues() |
||||
|
||||
sp := sync.NewProtocol(sync.Config{ |
||||
Chain: bc, |
||||
Host: host.GetP2PHost(), |
||||
Discovery: host.GetDiscovery(), |
||||
ShardID: nodeconfig.ShardID(bc.ShardID()), |
||||
Network: config.Network, |
||||
BeaconNode: isBeaconNode, |
||||
|
||||
SmSoftLowCap: config.SmSoftLowCap, |
||||
SmHardLowCap: config.SmHardLowCap, |
||||
SmHiCap: config.SmHiCap, |
||||
DiscBatch: config.SmDiscBatch, |
||||
}) |
||||
host.AddStreamProtocol(sp) |
||||
|
||||
var bh *beaconHelper |
||||
if config.BHConfig != nil && bc.ShardID() == 0 { |
||||
bh = newBeaconHelper(bc, config.BHConfig.BlockC, config.BHConfig.InsertHook) |
||||
} |
||||
|
||||
ctx, cancel := context.WithCancel(context.Background()) |
||||
|
||||
return &Downloader{ |
||||
bc: bc, |
||||
syncProtocol: sp, |
||||
bh: bh, |
||||
|
||||
downloadC: make(chan struct{}), |
||||
closeC: make(chan struct{}), |
||||
ctx: ctx, |
||||
cancel: cancel, |
||||
|
||||
status: newStatus(), |
||||
config: config, |
||||
logger: utils.Logger().With().Str("module", "downloader").Uint32("ShardID", bc.ShardID()).Logger(), |
||||
} |
||||
} |
||||
|
||||
// Start start the downloader
|
||||
func (d *Downloader) Start() { |
||||
go d.run() |
||||
|
||||
if d.bh != nil { |
||||
d.bh.start() |
||||
} |
||||
} |
||||
|
||||
// Close close the downloader
|
||||
func (d *Downloader) Close() { |
||||
close(d.closeC) |
||||
d.cancel() |
||||
|
||||
if d.bh != nil { |
||||
d.bh.close() |
||||
} |
||||
} |
||||
|
||||
// DownloadAsync triggers the download async.
|
||||
func (d *Downloader) DownloadAsync() { |
||||
select { |
||||
case d.downloadC <- struct{}{}: |
||||
consensusTriggeredDownloadCounterVec.With(d.promLabels()).Inc() |
||||
|
||||
case <-time.After(100 * time.Millisecond): |
||||
} |
||||
} |
||||
|
||||
// NumPeers returns the number of peers connected of a specific shard.
|
||||
func (d *Downloader) NumPeers() int { |
||||
return d.syncProtocol.NumStreams() |
||||
} |
||||
|
||||
// IsSyncing return the current sync status
|
||||
func (d *Downloader) SyncStatus() (bool, uint64, uint64) { |
||||
current := d.bc.CurrentBlock().NumberU64() |
||||
syncing, target := d.status.get() |
||||
if !syncing { // means synced
|
||||
target = current |
||||
} |
||||
// isSyncing, target, blocks to target
|
||||
return syncing, target, target - current |
||||
} |
||||
|
||||
// SubscribeDownloadStarted subscribe download started
|
||||
func (d *Downloader) SubscribeDownloadStarted(ch chan struct{}) event.Subscription { |
||||
d.evtDownloadStartedSubscribed = true |
||||
return d.evtDownloadStarted.Subscribe(ch) |
||||
} |
||||
|
||||
// SubscribeDownloadFinished subscribe the download finished
|
||||
func (d *Downloader) SubscribeDownloadFinished(ch chan struct{}) event.Subscription { |
||||
d.evtDownloadFinishedSubscribed = true |
||||
return d.evtDownloadFinished.Subscribe(ch) |
||||
} |
||||
|
||||
func (d *Downloader) run() { |
||||
d.waitForBootFinish() |
||||
d.loop() |
||||
} |
||||
|
||||
// waitForBootFinish wait for stream manager to finish the initial discovery and have
|
||||
// enough peers to start downloader
|
||||
func (d *Downloader) waitForBootFinish() { |
||||
evtCh := make(chan streammanager.EvtStreamAdded, 1) |
||||
sub := d.syncProtocol.SubscribeAddStreamEvent(evtCh) |
||||
defer sub.Unsubscribe() |
||||
|
||||
checkCh := make(chan struct{}, 1) |
||||
trigger := func() { |
||||
select { |
||||
case checkCh <- struct{}{}: |
||||
default: |
||||
} |
||||
} |
||||
trigger() |
||||
|
||||
t := time.NewTicker(10 * time.Second) |
||||
defer t.Stop() |
||||
for { |
||||
d.logger.Info().Msg("waiting for initial bootstrap discovery") |
||||
select { |
||||
case <-t.C: |
||||
trigger() |
||||
|
||||
case <-evtCh: |
||||
trigger() |
||||
|
||||
case <-checkCh: |
||||
if d.syncProtocol.NumStreams() >= d.config.InitStreams { |
||||
return |
||||
} |
||||
case <-d.closeC: |
||||
return |
||||
} |
||||
} |
||||
} |
||||
|
||||
func (d *Downloader) loop() { |
||||
ticker := time.NewTicker(10 * time.Second) |
||||
defer ticker.Stop() |
||||
initSync := true |
||||
trigger := func() { |
||||
select { |
||||
case d.downloadC <- struct{}{}: |
||||
case <-time.After(100 * time.Millisecond): |
||||
} |
||||
} |
||||
go trigger() |
||||
|
||||
for { |
||||
select { |
||||
case <-ticker.C: |
||||
go trigger() |
||||
|
||||
case <-d.downloadC: |
||||
addedBN, err := d.doDownload(initSync) |
||||
if err != nil { |
||||
// If error happens, sleep 5 seconds and retry
|
||||
d.logger.Warn().Err(err).Bool("bootstrap", initSync).Msg("failed to download") |
||||
go func() { |
||||
time.Sleep(5 * time.Second) |
||||
trigger() |
||||
}() |
||||
time.Sleep(1 * time.Second) |
||||
continue |
||||
} |
||||
d.logger.Info().Int("block added", addedBN). |
||||
Uint64("current height", d.bc.CurrentBlock().NumberU64()). |
||||
Bool("initSync", initSync). |
||||
Uint32("shard", d.bc.ShardID()). |
||||
Msg("sync finished") |
||||
|
||||
if addedBN != 0 { |
||||
// If block number has been changed, trigger another sync
|
||||
// and try to add last mile from pub-sub (blocking)
|
||||
go trigger() |
||||
if d.bh != nil { |
||||
d.bh.insertSync() |
||||
} |
||||
} |
||||
initSync = false |
||||
|
||||
case <-d.closeC: |
||||
return |
||||
} |
||||
} |
||||
} |
||||
|
||||
func (d *Downloader) doDownload(initSync bool) (n int, err error) { |
||||
if initSync { |
||||
d.logger.Info().Uint64("current number", d.bc.CurrentBlock().NumberU64()). |
||||
Uint32("shard ID", d.bc.ShardID()).Msg("start long range sync") |
||||
|
||||
n, err = d.doLongRangeSync() |
||||
} else { |
||||
d.logger.Info().Uint64("current number", d.bc.CurrentBlock().NumberU64()). |
||||
Uint32("shard ID", d.bc.ShardID()).Msg("start short range sync") |
||||
|
||||
n, err = d.doShortRangeSync() |
||||
} |
||||
if err != nil { |
||||
pl := d.promLabels() |
||||
pl["error"] = err.Error() |
||||
numFailedDownloadCounterVec.With(pl).Inc() |
||||
return |
||||
} |
||||
return |
||||
} |
||||
|
||||
func (d *Downloader) startSyncing() { |
||||
d.status.startSyncing() |
||||
if d.evtDownloadStartedSubscribed { |
||||
d.evtDownloadStarted.Send(struct{}{}) |
||||
} |
||||
} |
||||
|
||||
func (d *Downloader) finishSyncing() { |
||||
d.status.finishSyncing() |
||||
if d.evtDownloadFinishedSubscribed { |
||||
d.evtDownloadFinished.Send(struct{}{}) |
||||
} |
||||
} |
||||
|
||||
var emptySigVerifyErr *sigVerifyErr |
||||
|
||||
type sigVerifyErr struct { |
||||
err error |
||||
} |
||||
|
||||
func (e *sigVerifyErr) Error() string { |
||||
return fmt.Sprintf("[VerifyHeaderSignature] %v", e.err.Error()) |
||||
} |
||||
|
||||
func verifyAndInsertBlocks(bc blockChain, blocks types.Blocks) (int, error) { |
||||
for i, block := range blocks { |
||||
if err := verifyAndInsertBlock(bc, block, blocks[i+1:]...); err != nil { |
||||
return i, err |
||||
} |
||||
} |
||||
return len(blocks), nil |
||||
} |
||||
|
||||
func verifyAndInsertBlock(bc blockChain, block *types.Block, nextBlocks ...*types.Block) error { |
||||
var ( |
||||
sigBytes bls.SerializedSignature |
||||
bitmap []byte |
||||
err error |
||||
) |
||||
if len(nextBlocks) > 0 { |
||||
// get commit sig from the next block
|
||||
next := nextBlocks[0] |
||||
sigBytes = next.Header().LastCommitSignature() |
||||
bitmap = next.Header().LastCommitBitmap() |
||||
} else { |
||||
// get commit sig from current block
|
||||
sigBytes, bitmap, err = chain.ParseCommitSigAndBitmap(block.GetCurrentCommitSig()) |
||||
if err != nil { |
||||
return errors.Wrap(err, "parse commitSigAndBitmap") |
||||
} |
||||
} |
||||
|
||||
if err := bc.Engine().VerifyHeaderSignature(bc, block.Header(), sigBytes, bitmap); err != nil { |
||||
return &sigVerifyErr{err} |
||||
} |
||||
if err := bc.Engine().VerifyHeader(bc, block.Header(), true); err != nil { |
||||
return errors.Wrap(err, "[VerifyHeader]") |
||||
} |
||||
if _, err := bc.InsertChain(types.Blocks{block}, false); err != nil { |
||||
return errors.Wrap(err, "[InsertChain]") |
||||
} |
||||
return nil |
||||
} |
||||
@ -1,96 +0,0 @@ |
||||
package downloader |
||||
|
||||
import ( |
||||
"context" |
||||
"fmt" |
||||
"testing" |
||||
"time" |
||||
) |
||||
|
||||
func TestDownloader_Integration(t *testing.T) { |
||||
sp := newTestSyncProtocol(1000, 48, nil) |
||||
bc := newTestBlockChain(0, nil) |
||||
ctx, cancel := context.WithCancel(context.Background()) |
||||
c := Config{} |
||||
c.fixValues() // use default config values
|
||||
|
||||
d := &Downloader{ |
||||
bc: bc, |
||||
syncProtocol: sp, |
||||
downloadC: make(chan struct{}), |
||||
closeC: make(chan struct{}), |
||||
ctx: ctx, |
||||
cancel: cancel, |
||||
config: c, |
||||
} |
||||
|
||||
// subscribe download event
|
||||
finishedCh := make(chan struct{}, 1) |
||||
finishedSub := d.SubscribeDownloadFinished(finishedCh) |
||||
startedCh := make(chan struct{}, 1) |
||||
startedSub := d.SubscribeDownloadStarted(startedCh) |
||||
defer finishedSub.Unsubscribe() |
||||
defer startedSub.Unsubscribe() |
||||
|
||||
// Start the downloader
|
||||
d.Start() |
||||
defer d.Close() |
||||
|
||||
// During bootstrap, trigger two download task: one long range, one short range.
|
||||
// The second one will not trigger start / finish events.
|
||||
if err := checkReceiveChanMulTimes(startedCh, 1, 10*time.Second); err != nil { |
||||
t.Fatal(err) |
||||
} |
||||
if err := checkReceiveChanMulTimes(finishedCh, 1, 10*time.Second); err != nil { |
||||
t.Fatal(err) |
||||
} |
||||
if curBN := d.bc.CurrentBlock().NumberU64(); curBN != 1000 { |
||||
t.Fatal("blockchain not synced to the latest") |
||||
} |
||||
|
||||
// Increase the remote block number, and trigger one download task manually
|
||||
sp.changeBlockNumber(1010) |
||||
d.DownloadAsync() |
||||
// We shall do short range test twice
|
||||
if err := checkReceiveChanMulTimes(startedCh, 1, 10*time.Second); err != nil { |
||||
t.Fatal(err) |
||||
} |
||||
if err := checkReceiveChanMulTimes(finishedCh, 1, 10*time.Second); err != nil { |
||||
t.Fatal(err) |
||||
} |
||||
if curBN := d.bc.CurrentBlock().NumberU64(); curBN != 1010 { |
||||
t.Fatal("blockchain not synced to the latest") |
||||
} |
||||
|
||||
// Remote block number unchanged, and trigger one download task manually
|
||||
d.DownloadAsync() |
||||
if err := checkReceiveChanMulTimes(startedCh, 0, 10*time.Second); err != nil { |
||||
t.Fatal(err) |
||||
} |
||||
if err := checkReceiveChanMulTimes(finishedCh, 0, 10*time.Second); err != nil { |
||||
t.Fatal(err) |
||||
} |
||||
|
||||
// At last, check number of streams, should be exactly the same as the initial number
|
||||
if sp.numStreams != 48 { |
||||
t.Errorf("unexpected number of streams at the end: %v / %v", sp.numStreams, 48) |
||||
} |
||||
} |
||||
|
||||
func checkReceiveChanMulTimes(ch chan struct{}, times int, timeout time.Duration) error { |
||||
t := time.Tick(timeout) |
||||
|
||||
for i := 0; i != times; i++ { |
||||
select { |
||||
case <-ch: |
||||
case <-t: |
||||
return fmt.Errorf("timed out %v", timeout) |
||||
} |
||||
} |
||||
select { |
||||
case <-ch: |
||||
return fmt.Errorf("received an extra event") |
||||
case <-time.After(100 * time.Millisecond): |
||||
} |
||||
return nil |
||||
} |
||||
@ -1,97 +0,0 @@ |
||||
package downloader |
||||
|
||||
import ( |
||||
"github.com/harmony-one/abool" |
||||
"github.com/harmony-one/harmony/core" |
||||
"github.com/harmony-one/harmony/p2p" |
||||
) |
||||
|
||||
// Downloaders is the set of downloaders
|
||||
type Downloaders struct { |
||||
ds map[uint32]*Downloader |
||||
active *abool.AtomicBool |
||||
|
||||
config Config |
||||
} |
||||
|
||||
// NewDownloaders creates Downloaders for sync of multiple blockchains
|
||||
func NewDownloaders(host p2p.Host, bcs []core.BlockChain, config Config) *Downloaders { |
||||
ds := make(map[uint32]*Downloader) |
||||
isBeaconNode := len(bcs) == 1 |
||||
for _, bc := range bcs { |
||||
if bc == nil { |
||||
continue |
||||
} |
||||
if _, ok := ds[bc.ShardID()]; ok { |
||||
continue |
||||
} |
||||
ds[bc.ShardID()] = NewDownloader(host, bc, isBeaconNode, config) |
||||
} |
||||
return &Downloaders{ |
||||
ds: ds, |
||||
active: abool.New(), |
||||
config: config, |
||||
} |
||||
} |
||||
|
||||
// Start start the downloaders
|
||||
func (ds *Downloaders) Start() { |
||||
if ds.config.ServerOnly { |
||||
// Run in server only mode. Do not start downloaders.
|
||||
return |
||||
} |
||||
ds.active.Set() |
||||
for _, d := range ds.ds { |
||||
d.Start() |
||||
} |
||||
} |
||||
|
||||
// Close close the downloaders
|
||||
func (ds *Downloaders) Close() { |
||||
if ds.config.ServerOnly { |
||||
// Run in server only mode. Downloaders not started.
|
||||
return |
||||
} |
||||
ds.active.UnSet() |
||||
for _, d := range ds.ds { |
||||
d.Close() |
||||
} |
||||
} |
||||
|
||||
// DownloadAsync triggers a download
|
||||
func (ds *Downloaders) DownloadAsync(shardID uint32) { |
||||
d, ok := ds.ds[shardID] |
||||
if !ok && d != nil { |
||||
d.DownloadAsync() |
||||
} |
||||
} |
||||
|
||||
// GetShardDownloader get the downloader with the given shard ID
|
||||
func (ds *Downloaders) GetShardDownloader(shardID uint32) *Downloader { |
||||
return ds.ds[shardID] |
||||
} |
||||
|
||||
// NumPeers returns the connected peers for each shard
|
||||
func (ds *Downloaders) NumPeers() map[uint32]int { |
||||
res := make(map[uint32]int) |
||||
|
||||
for sid, d := range ds.ds { |
||||
res[sid] = d.NumPeers() |
||||
} |
||||
return res |
||||
} |
||||
|
||||
// SyncStatus returns whether the given shard is doing syncing task and the target block
|
||||
// number.
|
||||
func (ds *Downloaders) SyncStatus(shardID uint32) (bool, uint64, uint64) { |
||||
d, ok := ds.ds[shardID] |
||||
if !ok { |
||||
return false, 0, 0 |
||||
} |
||||
return d.SyncStatus() |
||||
} |
||||
|
||||
// IsActive returns whether the downloader is active
|
||||
func (ds *Downloaders) IsActive() bool { |
||||
return ds.active.IsSet() |
||||
} |
||||
@ -1,522 +0,0 @@ |
||||
package downloader |
||||
|
||||
import ( |
||||
"context" |
||||
"fmt" |
||||
"sync" |
||||
"time" |
||||
|
||||
"github.com/harmony-one/harmony/core/types" |
||||
syncproto "github.com/harmony-one/harmony/p2p/stream/protocols/sync" |
||||
sttypes "github.com/harmony-one/harmony/p2p/stream/types" |
||||
"github.com/pkg/errors" |
||||
"github.com/rs/zerolog" |
||||
) |
||||
|
||||
// doLongRangeSync does the long range sync.
|
||||
// One LongRangeSync consists of several iterations.
|
||||
// For each iteration, estimate the current block number, then fetch block & insert to blockchain
|
||||
func (d *Downloader) doLongRangeSync() (int, error) { |
||||
var totalInserted int |
||||
|
||||
for { |
||||
ctx, cancel := context.WithCancel(d.ctx) |
||||
|
||||
iter := &lrSyncIter{ |
||||
bc: d.bc, |
||||
p: d.syncProtocol, |
||||
d: d, |
||||
ctx: ctx, |
||||
config: d.config, |
||||
logger: d.logger.With().Str("mode", "long range").Logger(), |
||||
} |
||||
if err := iter.doLongRangeSync(); err != nil { |
||||
cancel() |
||||
return totalInserted + iter.inserted, err |
||||
} |
||||
cancel() |
||||
|
||||
totalInserted += iter.inserted |
||||
|
||||
if iter.inserted < lastMileThres { |
||||
return totalInserted, nil |
||||
} |
||||
} |
||||
} |
||||
|
||||
// lrSyncIter run a single iteration of a full long range sync.
|
||||
// First get a rough estimate of the current block height, and then sync to this
|
||||
// block number
|
||||
type lrSyncIter struct { |
||||
bc blockChain |
||||
p syncProtocol |
||||
d *Downloader |
||||
|
||||
gbm *getBlocksManager // initialized when finished get block number
|
||||
inserted int |
||||
|
||||
config Config |
||||
ctx context.Context |
||||
logger zerolog.Logger |
||||
} |
||||
|
||||
func (lsi *lrSyncIter) doLongRangeSync() error { |
||||
if err := lsi.checkPrerequisites(); err != nil { |
||||
return err |
||||
} |
||||
bn, err := lsi.estimateCurrentNumber() |
||||
if err != nil { |
||||
return err |
||||
} |
||||
if curBN := lsi.bc.CurrentBlock().NumberU64(); bn <= curBN { |
||||
lsi.logger.Info().Uint64("current number", curBN).Uint64("target number", bn). |
||||
Msg("early return of long range sync") |
||||
return nil |
||||
} |
||||
|
||||
lsi.d.startSyncing() |
||||
defer lsi.d.finishSyncing() |
||||
|
||||
lsi.logger.Info().Uint64("target number", bn).Msg("estimated remote current number") |
||||
lsi.d.status.setTargetBN(bn) |
||||
|
||||
return lsi.fetchAndInsertBlocks(bn) |
||||
} |
||||
|
||||
func (lsi *lrSyncIter) checkPrerequisites() error { |
||||
return lsi.checkHaveEnoughStreams() |
||||
} |
||||
|
||||
// estimateCurrentNumber roughly estimate the current block number.
|
||||
// The block number does not need to be exact, but just a temporary target of the iteration
|
||||
func (lsi *lrSyncIter) estimateCurrentNumber() (uint64, error) { |
||||
var ( |
||||
cnResults = make(map[sttypes.StreamID]uint64) |
||||
lock sync.Mutex |
||||
wg sync.WaitGroup |
||||
) |
||||
wg.Add(lsi.config.Concurrency) |
||||
for i := 0; i != lsi.config.Concurrency; i++ { |
||||
go func() { |
||||
defer wg.Done() |
||||
bn, stid, err := lsi.doGetCurrentNumberRequest() |
||||
if err != nil { |
||||
lsi.logger.Err(err).Str("streamID", string(stid)). |
||||
Msg("getCurrentNumber request failed. Removing stream") |
||||
if !errors.Is(err, context.Canceled) { |
||||
lsi.p.RemoveStream(stid) |
||||
} |
||||
return |
||||
} |
||||
lock.Lock() |
||||
cnResults[stid] = bn |
||||
lock.Unlock() |
||||
}() |
||||
} |
||||
wg.Wait() |
||||
|
||||
if len(cnResults) == 0 { |
||||
select { |
||||
case <-lsi.ctx.Done(): |
||||
return 0, lsi.ctx.Err() |
||||
default: |
||||
} |
||||
return 0, errors.New("zero block number response from remote nodes") |
||||
} |
||||
bn := computeBlockNumberByMaxVote(cnResults) |
||||
return bn, nil |
||||
} |
||||
|
||||
func (lsi *lrSyncIter) doGetCurrentNumberRequest() (uint64, sttypes.StreamID, error) { |
||||
ctx, cancel := context.WithTimeout(lsi.ctx, 10*time.Second) |
||||
defer cancel() |
||||
|
||||
bn, stid, err := lsi.p.GetCurrentBlockNumber(ctx, syncproto.WithHighPriority()) |
||||
if err != nil { |
||||
return 0, stid, err |
||||
} |
||||
return bn, stid, nil |
||||
} |
||||
|
||||
// fetchAndInsertBlocks use the pipeline pattern to boost the performance of inserting blocks.
|
||||
// TODO: For resharding, use the pipeline to do fast sync (epoch loop, header loop, body loop)
|
||||
func (lsi *lrSyncIter) fetchAndInsertBlocks(targetBN uint64) error { |
||||
gbm := newGetBlocksManager(lsi.bc, targetBN, lsi.logger) |
||||
lsi.gbm = gbm |
||||
|
||||
// Setup workers to fetch blocks from remote node
|
||||
for i := 0; i != lsi.config.Concurrency; i++ { |
||||
worker := &getBlocksWorker{ |
||||
gbm: gbm, |
||||
protocol: lsi.p, |
||||
} |
||||
go worker.workLoop(lsi.ctx) |
||||
} |
||||
|
||||
// insert the blocks to chain. Return when the target block number is reached.
|
||||
lsi.insertChainLoop(targetBN) |
||||
|
||||
select { |
||||
case <-lsi.ctx.Done(): |
||||
return lsi.ctx.Err() |
||||
default: |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
func (lsi *lrSyncIter) insertChainLoop(targetBN uint64) { |
||||
var ( |
||||
gbm = lsi.gbm |
||||
t = time.NewTicker(100 * time.Millisecond) |
||||
resultC = make(chan struct{}, 1) |
||||
) |
||||
defer t.Stop() |
||||
|
||||
trigger := func() { |
||||
select { |
||||
case resultC <- struct{}{}: |
||||
default: |
||||
} |
||||
} |
||||
|
||||
for { |
||||
select { |
||||
case <-lsi.ctx.Done(): |
||||
return |
||||
|
||||
case <-t.C: |
||||
// Redundancy, periodically check whether there is blocks that can be processed
|
||||
trigger() |
||||
|
||||
case <-gbm.resultC: |
||||
// New block arrive in resultQueue
|
||||
trigger() |
||||
|
||||
case <-resultC: |
||||
blockResults := gbm.PullContinuousBlocks(blocksPerInsert) |
||||
if len(blockResults) > 0 { |
||||
lsi.processBlocks(blockResults, targetBN) |
||||
// more blocks is expected being able to be pulled from queue
|
||||
trigger() |
||||
} |
||||
if lsi.bc.CurrentBlock().NumberU64() >= targetBN { |
||||
return |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
func (lsi *lrSyncIter) processBlocks(results []*blockResult, targetBN uint64) { |
||||
blocks := blockResultsToBlocks(results) |
||||
|
||||
for i, block := range blocks { |
||||
if err := verifyAndInsertBlock(lsi.bc, block); err != nil { |
||||
lsi.logger.Warn().Err(err).Uint64("target block", targetBN). |
||||
Uint64("block number", block.NumberU64()). |
||||
Msg("insert blocks failed in long range") |
||||
pl := lsi.d.promLabels() |
||||
pl["error"] = err.Error() |
||||
longRangeFailInsertedBlockCounterVec.With(pl).Inc() |
||||
|
||||
lsi.p.RemoveStream(results[i].stid) |
||||
lsi.gbm.HandleInsertError(results, i) |
||||
return |
||||
} |
||||
|
||||
lsi.inserted++ |
||||
longRangeSyncedBlockCounterVec.With(lsi.d.promLabels()).Inc() |
||||
} |
||||
lsi.gbm.HandleInsertResult(results) |
||||
} |
||||
|
||||
func (lsi *lrSyncIter) checkHaveEnoughStreams() error { |
||||
numStreams := lsi.p.NumStreams() |
||||
if numStreams < lsi.config.MinStreams { |
||||
return fmt.Errorf("number of streams smaller than minimum: %v < %v", |
||||
numStreams, lsi.config.MinStreams) |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
// getBlocksWorker does the request job
|
||||
type getBlocksWorker struct { |
||||
gbm *getBlocksManager |
||||
protocol syncProtocol |
||||
} |
||||
|
||||
func (w *getBlocksWorker) workLoop(ctx context.Context) { |
||||
for { |
||||
select { |
||||
case <-ctx.Done(): |
||||
return |
||||
default: |
||||
} |
||||
batch := w.gbm.GetNextBatch() |
||||
if len(batch) == 0 { |
||||
select { |
||||
case <-ctx.Done(): |
||||
return |
||||
case <-time.After(100 * time.Millisecond): |
||||
continue |
||||
} |
||||
} |
||||
|
||||
blocks, stid, err := w.doBatch(ctx, batch) |
||||
if err != nil { |
||||
if !errors.Is(err, context.Canceled) { |
||||
w.protocol.RemoveStream(stid) |
||||
} |
||||
err = errors.Wrap(err, "request error") |
||||
w.gbm.HandleRequestError(batch, err, stid) |
||||
} else { |
||||
w.gbm.HandleRequestResult(batch, blocks, stid) |
||||
} |
||||
} |
||||
} |
||||
|
||||
func (w *getBlocksWorker) doBatch(ctx context.Context, bns []uint64) ([]*types.Block, sttypes.StreamID, error) { |
||||
ctx, cancel := context.WithTimeout(ctx, 10*time.Second) |
||||
defer cancel() |
||||
|
||||
blocks, stid, err := w.protocol.GetBlocksByNumber(ctx, bns) |
||||
if err != nil { |
||||
return nil, stid, err |
||||
} |
||||
if err := validateGetBlocksResult(bns, blocks); err != nil { |
||||
return nil, stid, err |
||||
} |
||||
return blocks, stid, nil |
||||
} |
||||
|
||||
// getBlocksManager is the helper structure for get blocks request management
|
||||
type getBlocksManager struct { |
||||
chain blockChain |
||||
|
||||
targetBN uint64 |
||||
requesting map[uint64]struct{} // block numbers that have been assigned to workers but not received
|
||||
processing map[uint64]struct{} // block numbers received requests but not inserted
|
||||
retries *prioritizedNumbers // requests where error happens
|
||||
rq *resultQueue // result queue wait to be inserted into blockchain
|
||||
|
||||
resultC chan struct{} |
||||
logger zerolog.Logger |
||||
lock sync.Mutex |
||||
} |
||||
|
||||
func newGetBlocksManager(chain blockChain, targetBN uint64, logger zerolog.Logger) *getBlocksManager { |
||||
return &getBlocksManager{ |
||||
chain: chain, |
||||
targetBN: targetBN, |
||||
requesting: make(map[uint64]struct{}), |
||||
processing: make(map[uint64]struct{}), |
||||
retries: newPrioritizedNumbers(), |
||||
rq: newResultQueue(), |
||||
resultC: make(chan struct{}, 1), |
||||
logger: logger, |
||||
} |
||||
} |
||||
|
||||
// GetNextBatch get the next block numbers batch
|
||||
func (gbm *getBlocksManager) GetNextBatch() []uint64 { |
||||
gbm.lock.Lock() |
||||
defer gbm.lock.Unlock() |
||||
|
||||
cap := numBlocksByNumPerRequest |
||||
|
||||
bns := gbm.getBatchFromRetries(cap) |
||||
cap -= len(bns) |
||||
gbm.addBatchToRequesting(bns) |
||||
|
||||
if gbm.availableForMoreTasks() { |
||||
addBNs := gbm.getBatchFromUnprocessed(cap) |
||||
gbm.addBatchToRequesting(addBNs) |
||||
bns = append(bns, addBNs...) |
||||
} |
||||
|
||||
return bns |
||||
} |
||||
|
||||
// HandleRequestError handles the error result
|
||||
func (gbm *getBlocksManager) HandleRequestError(bns []uint64, err error, stid sttypes.StreamID) { |
||||
gbm.lock.Lock() |
||||
defer gbm.lock.Unlock() |
||||
|
||||
gbm.logger.Warn().Err(err).Str("stream", string(stid)).Msg("get blocks error") |
||||
|
||||
// add requested block numbers to retries
|
||||
for _, bn := range bns { |
||||
delete(gbm.requesting, bn) |
||||
gbm.retries.push(bn) |
||||
} |
||||
|
||||
// remove results from result queue by the stream and add back to retries
|
||||
removed := gbm.rq.removeResultsByStreamID(stid) |
||||
for _, bn := range removed { |
||||
delete(gbm.processing, bn) |
||||
gbm.retries.push(bn) |
||||
} |
||||
} |
||||
|
||||
// HandleRequestResult handles get blocks result
|
||||
func (gbm *getBlocksManager) HandleRequestResult(bns []uint64, blocks []*types.Block, stid sttypes.StreamID) { |
||||
gbm.lock.Lock() |
||||
defer gbm.lock.Unlock() |
||||
|
||||
for i, bn := range bns { |
||||
delete(gbm.requesting, bn) |
||||
if blocks[i] == nil { |
||||
gbm.retries.push(bn) |
||||
} else { |
||||
gbm.processing[bn] = struct{}{} |
||||
} |
||||
} |
||||
gbm.rq.addBlockResults(blocks, stid) |
||||
select { |
||||
case gbm.resultC <- struct{}{}: |
||||
default: |
||||
} |
||||
} |
||||
|
||||
// HandleInsertResult handle the insert result
|
||||
func (gbm *getBlocksManager) HandleInsertResult(inserted []*blockResult) { |
||||
gbm.lock.Lock() |
||||
defer gbm.lock.Unlock() |
||||
|
||||
for _, block := range inserted { |
||||
delete(gbm.processing, block.getBlockNumber()) |
||||
} |
||||
} |
||||
|
||||
// HandleInsertError handles the error during InsertChain
|
||||
func (gbm *getBlocksManager) HandleInsertError(results []*blockResult, n int) { |
||||
gbm.lock.Lock() |
||||
defer gbm.lock.Unlock() |
||||
|
||||
var ( |
||||
inserted []*blockResult |
||||
errResult *blockResult |
||||
abandoned []*blockResult |
||||
) |
||||
inserted = results[:n] |
||||
errResult = results[n] |
||||
if n != len(results) { |
||||
abandoned = results[n+1:] |
||||
} |
||||
|
||||
for _, res := range inserted { |
||||
delete(gbm.processing, res.getBlockNumber()) |
||||
} |
||||
for _, res := range abandoned { |
||||
gbm.rq.addBlockResults([]*types.Block{res.block}, res.stid) |
||||
} |
||||
|
||||
delete(gbm.processing, errResult.getBlockNumber()) |
||||
gbm.retries.push(errResult.getBlockNumber()) |
||||
|
||||
removed := gbm.rq.removeResultsByStreamID(errResult.stid) |
||||
for _, bn := range removed { |
||||
delete(gbm.processing, bn) |
||||
gbm.retries.push(bn) |
||||
} |
||||
} |
||||
|
||||
// PullContinuousBlocks pull continuous blocks from request queue
|
||||
func (gbm *getBlocksManager) PullContinuousBlocks(cap int) []*blockResult { |
||||
gbm.lock.Lock() |
||||
defer gbm.lock.Unlock() |
||||
|
||||
expHeight := gbm.chain.CurrentBlock().NumberU64() + 1 |
||||
results, stales := gbm.rq.popBlockResults(expHeight, cap) |
||||
// For stale blocks, we remove them from processing
|
||||
for _, bn := range stales { |
||||
delete(gbm.processing, bn) |
||||
} |
||||
return results |
||||
} |
||||
|
||||
// getBatchFromRetries get the block number batch to be requested from retries.
|
||||
func (gbm *getBlocksManager) getBatchFromRetries(cap int) []uint64 { |
||||
var ( |
||||
requestBNs []uint64 |
||||
curHeight = gbm.chain.CurrentBlock().NumberU64() |
||||
) |
||||
for cnt := 0; cnt < cap; cnt++ { |
||||
bn := gbm.retries.pop() |
||||
if bn == 0 { |
||||
break // no more retries
|
||||
} |
||||
if bn <= curHeight { |
||||
continue |
||||
} |
||||
requestBNs = append(requestBNs, bn) |
||||
} |
||||
return requestBNs |
||||
} |
||||
|
||||
// getBatchFromRetries get the block number batch to be requested from unprocessed.
|
||||
func (gbm *getBlocksManager) getBatchFromUnprocessed(cap int) []uint64 { |
||||
var ( |
||||
requestBNs []uint64 |
||||
curHeight = gbm.chain.CurrentBlock().NumberU64() |
||||
) |
||||
bn := curHeight + 1 |
||||
// TODO: this algorithm can be potentially optimized.
|
||||
for cnt := 0; cnt < cap && bn <= gbm.targetBN; cnt++ { |
||||
for bn <= gbm.targetBN { |
||||
_, ok1 := gbm.requesting[bn] |
||||
_, ok2 := gbm.processing[bn] |
||||
if !ok1 && !ok2 { |
||||
requestBNs = append(requestBNs, bn) |
||||
bn++ |
||||
break |
||||
} |
||||
bn++ |
||||
} |
||||
} |
||||
return requestBNs |
||||
} |
||||
|
||||
func (gbm *getBlocksManager) availableForMoreTasks() bool { |
||||
return gbm.rq.results.Len() < softQueueCap |
||||
} |
||||
|
||||
func (gbm *getBlocksManager) addBatchToRequesting(bns []uint64) { |
||||
for _, bn := range bns { |
||||
gbm.requesting[bn] = struct{}{} |
||||
} |
||||
} |
||||
|
||||
func validateGetBlocksResult(requested []uint64, result []*types.Block) error { |
||||
if len(result) != len(requested) { |
||||
return fmt.Errorf("unexpected number of blocks delivered: %v / %v", len(result), len(requested)) |
||||
} |
||||
for i, block := range result { |
||||
if block != nil && block.NumberU64() != requested[i] { |
||||
return fmt.Errorf("block with unexpected number delivered: %v / %v", block.NumberU64(), requested[i]) |
||||
} |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
// computeBlockNumberByMaxVote compute the target block number by max vote.
|
||||
func computeBlockNumberByMaxVote(votes map[sttypes.StreamID]uint64) uint64 { |
||||
var ( |
||||
nm = make(map[uint64]int) |
||||
res uint64 |
||||
maxCnt int |
||||
) |
||||
for _, bn := range votes { |
||||
_, ok := nm[bn] |
||||
if !ok { |
||||
nm[bn] = 0 |
||||
} |
||||
nm[bn]++ |
||||
cnt := nm[bn] |
||||
|
||||
if cnt > maxCnt || (cnt == maxCnt && bn > res) { |
||||
res = bn |
||||
maxCnt = cnt |
||||
} |
||||
} |
||||
return res |
||||
} |
||||
@ -1,331 +0,0 @@ |
||||
package downloader |
||||
|
||||
import ( |
||||
"context" |
||||
"fmt" |
||||
"math/rand" |
||||
"sync" |
||||
"testing" |
||||
|
||||
sttypes "github.com/harmony-one/harmony/p2p/stream/types" |
||||
"github.com/pkg/errors" |
||||
) |
||||
|
||||
func TestDownloader_doLongRangeSync(t *testing.T) { |
||||
targetBN := uint64(1000) |
||||
bc := newTestBlockChain(1, nil) |
||||
|
||||
d := &Downloader{ |
||||
bc: bc, |
||||
syncProtocol: newTestSyncProtocol(targetBN, 32, nil), |
||||
config: Config{ |
||||
Concurrency: 16, |
||||
MinStreams: 16, |
||||
}, |
||||
ctx: context.Background(), |
||||
} |
||||
synced, err := d.doLongRangeSync() |
||||
if err != nil { |
||||
t.Error(err) |
||||
} |
||||
if synced == 0 { |
||||
t.Errorf("synced false") |
||||
} |
||||
if curNum := d.bc.CurrentBlock().NumberU64(); curNum != targetBN { |
||||
t.Errorf("block number not expected: %v / %v", curNum, targetBN) |
||||
} |
||||
} |
||||
|
||||
func TestLrSyncIter_EstimateCurrentNumber(t *testing.T) { |
||||
lsi := &lrSyncIter{ |
||||
p: newTestSyncProtocol(100, 32, nil), |
||||
ctx: context.Background(), |
||||
config: Config{ |
||||
Concurrency: 16, |
||||
MinStreams: 10, |
||||
}, |
||||
} |
||||
bn, err := lsi.estimateCurrentNumber() |
||||
if err != nil { |
||||
t.Error(err) |
||||
} |
||||
if bn != 100 { |
||||
t.Errorf("unexpected block number: %v / %v", bn, 100) |
||||
} |
||||
} |
||||
|
||||
func TestGetBlocksManager_GetNextBatch(t *testing.T) { |
||||
tests := []struct { |
||||
gbm *getBlocksManager |
||||
expBNs []uint64 |
||||
}{ |
||||
{ |
||||
gbm: makeGetBlocksManager( |
||||
10, 100, []uint64{9, 11, 12, 13}, |
||||
[]uint64{14, 15, 16}, []uint64{}, 0, |
||||
), |
||||
expBNs: []uint64{17, 18, 19, 20, 21, 22, 23, 24, 25, 26}, |
||||
}, |
||||
{ |
||||
gbm: makeGetBlocksManager( |
||||
10, 100, []uint64{9, 13, 14, 15, 16}, |
||||
[]uint64{}, []uint64{10, 11, 12}, 0, |
||||
), |
||||
expBNs: []uint64{11, 12, 17, 18, 19, 20, 21, 22, 23, 24}, |
||||
}, |
||||
{ |
||||
gbm: makeGetBlocksManager( |
||||
10, 100, []uint64{9, 13, 14, 15, 16}, |
||||
[]uint64{}, []uint64{10, 11, 12}, 120, |
||||
), |
||||
expBNs: []uint64{11, 12}, |
||||
}, |
||||
{ |
||||
gbm: makeGetBlocksManager( |
||||
10, 100, []uint64{9, 13, 14, 15, 16}, |
||||
[]uint64{}, []uint64{}, 120, |
||||
), |
||||
expBNs: []uint64{}, |
||||
}, |
||||
{ |
||||
gbm: makeGetBlocksManager( |
||||
10, 20, []uint64{9, 13, 14, 15, 16}, |
||||
[]uint64{}, []uint64{}, 0, |
||||
), |
||||
expBNs: []uint64{11, 12, 17, 18, 19, 20}, |
||||
}, |
||||
{ |
||||
gbm: makeGetBlocksManager( |
||||
10, 100, []uint64{9, 13, 14, 15, 16}, |
||||
[]uint64{}, []uint64{}, 0, |
||||
), |
||||
expBNs: []uint64{11, 12, 17, 18, 19, 20, 21, 22, 23, 24}, |
||||
}, |
||||
} |
||||
|
||||
for i, test := range tests { |
||||
if i < 4 { |
||||
continue |
||||
} |
||||
batch := test.gbm.GetNextBatch() |
||||
if len(test.expBNs) != len(batch) { |
||||
t.Errorf("Test %v: unexpected size [%v] / [%v]", i, batch, test.expBNs) |
||||
} |
||||
for i := range test.expBNs { |
||||
if test.expBNs[i] != batch[i] { |
||||
t.Errorf("Test %v: [%v] / [%v]", i, batch, test.expBNs) |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
func TestLrSyncIter_FetchAndInsertBlocks(t *testing.T) { |
||||
targetBN := uint64(1000) |
||||
chain := newTestBlockChain(0, nil) |
||||
protocol := newTestSyncProtocol(targetBN, 32, nil) |
||||
ctx := context.Background() |
||||
|
||||
lsi := &lrSyncIter{ |
||||
bc: chain, |
||||
d: &Downloader{bc: chain}, |
||||
p: protocol, |
||||
gbm: nil, |
||||
config: Config{ |
||||
Concurrency: 100, |
||||
}, |
||||
ctx: ctx, |
||||
} |
||||
lsi.fetchAndInsertBlocks(targetBN) |
||||
|
||||
if err := fetchAndInsertBlocksResultCheck(lsi, targetBN, initStreamNum); err != nil { |
||||
t.Error(err) |
||||
} |
||||
} |
||||
|
||||
// When FetchAndInsertBlocks, one request has an error
|
||||
func TestLrSyncIter_FetchAndInsertBlocks_ErrRequest(t *testing.T) { |
||||
targetBN := uint64(1000) |
||||
var once sync.Once |
||||
errHook := func(bn uint64) error { |
||||
var err error |
||||
once.Do(func() { |
||||
err = errors.New("test error expected") |
||||
}) |
||||
return err |
||||
} |
||||
chain := newTestBlockChain(0, nil) |
||||
protocol := newTestSyncProtocol(targetBN, 32, errHook) |
||||
ctx := context.Background() |
||||
|
||||
lsi := &lrSyncIter{ |
||||
bc: chain, |
||||
d: &Downloader{bc: chain}, |
||||
p: protocol, |
||||
gbm: nil, |
||||
config: Config{ |
||||
Concurrency: 100, |
||||
}, |
||||
ctx: ctx, |
||||
} |
||||
lsi.fetchAndInsertBlocks(targetBN) |
||||
|
||||
if err := fetchAndInsertBlocksResultCheck(lsi, targetBN, initStreamNum-1); err != nil { |
||||
t.Error(err) |
||||
} |
||||
} |
||||
|
||||
// When FetchAndInsertBlocks, one insertion has an error
|
||||
func TestLrSyncIter_FetchAndInsertBlocks_ErrInsert(t *testing.T) { |
||||
targetBN := uint64(1000) |
||||
var once sync.Once |
||||
errHook := func(bn uint64) error { |
||||
var err error |
||||
once.Do(func() { |
||||
err = errors.New("test error expected") |
||||
}) |
||||
return err |
||||
} |
||||
chain := newTestBlockChain(0, errHook) |
||||
protocol := newTestSyncProtocol(targetBN, 32, nil) |
||||
ctx := context.Background() |
||||
|
||||
lsi := &lrSyncIter{ |
||||
bc: chain, |
||||
d: &Downloader{bc: chain}, |
||||
p: protocol, |
||||
gbm: nil, |
||||
config: Config{ |
||||
Concurrency: 100, |
||||
}, |
||||
ctx: ctx, |
||||
} |
||||
lsi.fetchAndInsertBlocks(targetBN) |
||||
|
||||
if err := fetchAndInsertBlocksResultCheck(lsi, targetBN, initStreamNum-1); err != nil { |
||||
t.Error(err) |
||||
} |
||||
} |
||||
|
||||
// When FetchAndInsertBlocks, randomly error happens
|
||||
func TestLrSyncIter_FetchAndInsertBlocks_RandomErr(t *testing.T) { |
||||
targetBN := uint64(10000) |
||||
rand.Seed(0) |
||||
errHook := func(bn uint64) error { |
||||
// 10% error happens
|
||||
if rand.Intn(10)%10 == 0 { |
||||
return errors.New("error expected") |
||||
} |
||||
return nil |
||||
} |
||||
chain := newTestBlockChain(0, errHook) |
||||
protocol := newTestSyncProtocol(targetBN, 32, errHook) |
||||
ctx := context.Background() |
||||
|
||||
lsi := &lrSyncIter{ |
||||
bc: chain, |
||||
d: &Downloader{bc: chain}, |
||||
p: protocol, |
||||
gbm: nil, |
||||
config: Config{ |
||||
Concurrency: 100, |
||||
}, |
||||
ctx: ctx, |
||||
} |
||||
lsi.fetchAndInsertBlocks(targetBN) |
||||
|
||||
if err := fetchAndInsertBlocksResultCheck(lsi, targetBN, minStreamNum); err != nil { |
||||
t.Error(err) |
||||
} |
||||
} |
||||
|
||||
func fetchAndInsertBlocksResultCheck(lsi *lrSyncIter, targetBN uint64, expNumStreams int) error { |
||||
if bn := lsi.bc.CurrentBlock().NumberU64(); bn != targetBN { |
||||
return fmt.Errorf("did not reached targetBN: %v / %v", bn, targetBN) |
||||
} |
||||
lsi.gbm.lock.Lock() |
||||
defer lsi.gbm.lock.Unlock() |
||||
if len(lsi.gbm.processing) != 0 { |
||||
return fmt.Errorf("not empty processing: %v", lsi.gbm.processing) |
||||
} |
||||
if len(lsi.gbm.requesting) != 0 { |
||||
return fmt.Errorf("not empty requesting: %v", lsi.gbm.requesting) |
||||
} |
||||
if lsi.gbm.retries.length() != 0 { |
||||
return fmt.Errorf("not empty retries: %v", lsi.gbm.retries) |
||||
} |
||||
if lsi.gbm.rq.length() != 0 { |
||||
return fmt.Errorf("not empty result queue: %v", lsi.gbm.rq.results) |
||||
} |
||||
tsp := lsi.p.(*testSyncProtocol) |
||||
if len(tsp.streamIDs) != expNumStreams { |
||||
return fmt.Errorf("num streams not expected: %v / %v", len(tsp.streamIDs), expNumStreams) |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
func TestComputeBNMaxVote(t *testing.T) { |
||||
tests := []struct { |
||||
votes map[sttypes.StreamID]uint64 |
||||
exp uint64 |
||||
}{ |
||||
{ |
||||
votes: map[sttypes.StreamID]uint64{ |
||||
makeStreamID(0): 10, |
||||
makeStreamID(1): 10, |
||||
makeStreamID(2): 20, |
||||
}, |
||||
exp: 10, |
||||
}, |
||||
{ |
||||
votes: map[sttypes.StreamID]uint64{ |
||||
makeStreamID(0): 10, |
||||
makeStreamID(1): 20, |
||||
}, |
||||
exp: 20, |
||||
}, |
||||
{ |
||||
votes: map[sttypes.StreamID]uint64{ |
||||
makeStreamID(0): 20, |
||||
makeStreamID(1): 10, |
||||
makeStreamID(2): 20, |
||||
}, |
||||
exp: 20, |
||||
}, |
||||
} |
||||
|
||||
for i, test := range tests { |
||||
res := computeBlockNumberByMaxVote(test.votes) |
||||
if res != test.exp { |
||||
t.Errorf("Test %v: unexpected bn %v / %v", i, res, test.exp) |
||||
} |
||||
} |
||||
} |
||||
|
||||
func makeGetBlocksManager(curBN, targetBN uint64, requesting, processing, retries []uint64, sizeRQ int) *getBlocksManager { |
||||
chain := newTestBlockChain(curBN, nil) |
||||
requestingM := make(map[uint64]struct{}) |
||||
for _, bn := range requesting { |
||||
requestingM[bn] = struct{}{} |
||||
} |
||||
processingM := make(map[uint64]struct{}) |
||||
for _, bn := range processing { |
||||
processingM[bn] = struct{}{} |
||||
} |
||||
retriesPN := newPrioritizedNumbers() |
||||
for _, retry := range retries { |
||||
retriesPN.push(retry) |
||||
} |
||||
rq := newResultQueue() |
||||
for i := uint64(0); i != uint64(sizeRQ); i++ { |
||||
rq.addBlockResults(makeTestBlocks([]uint64{i + curBN}), "") |
||||
} |
||||
return &getBlocksManager{ |
||||
chain: chain, |
||||
targetBN: targetBN, |
||||
requesting: requestingM, |
||||
processing: processingM, |
||||
retries: retriesPN, |
||||
rq: rq, |
||||
resultC: make(chan struct{}, 1), |
||||
} |
||||
} |
||||
@ -1,98 +0,0 @@ |
||||
package downloader |
||||
|
||||
import ( |
||||
"fmt" |
||||
|
||||
prom "github.com/harmony-one/harmony/api/service/prometheus" |
||||
"github.com/prometheus/client_golang/prometheus" |
||||
) |
||||
|
||||
func init() { |
||||
prom.PromRegistry().MustRegister( |
||||
consensusTriggeredDownloadCounterVec, |
||||
longRangeSyncedBlockCounterVec, |
||||
longRangeFailInsertedBlockCounterVec, |
||||
numShortRangeCounterVec, |
||||
numFailedDownloadCounterVec, |
||||
numBlocksInsertedShortRangeHistogramVec, |
||||
numBlocksInsertedBeaconHelperCounter, |
||||
) |
||||
} |
||||
|
||||
var ( |
||||
consensusTriggeredDownloadCounterVec = prometheus.NewCounterVec( |
||||
prometheus.CounterOpts{ |
||||
Namespace: "hmy", |
||||
Subsystem: "downloader", |
||||
Name: "consensus_trigger", |
||||
Help: "number of times consensus triggered download task", |
||||
}, |
||||
[]string{"ShardID"}, |
||||
) |
||||
|
||||
longRangeSyncedBlockCounterVec = prometheus.NewCounterVec( |
||||
prometheus.CounterOpts{ |
||||
Namespace: "hmy", |
||||
Subsystem: "downloader", |
||||
Name: "num_blocks_synced_long_range", |
||||
Help: "number of blocks synced in long range sync", |
||||
}, |
||||
[]string{"ShardID"}, |
||||
) |
||||
|
||||
longRangeFailInsertedBlockCounterVec = prometheus.NewCounterVec( |
||||
prometheus.CounterOpts{ |
||||
Namespace: "hmy", |
||||
Subsystem: "downloader", |
||||
Name: "num_blocks_failed_long_range", |
||||
Help: "number of blocks failed to insert into change in long range sync", |
||||
}, |
||||
[]string{"ShardID", "error"}, |
||||
) |
||||
|
||||
numShortRangeCounterVec = prometheus.NewCounterVec( |
||||
prometheus.CounterOpts{ |
||||
Namespace: "hmy", |
||||
Subsystem: "downloader", |
||||
Name: "num_short_range", |
||||
Help: "number of short range sync is triggered", |
||||
}, |
||||
[]string{"ShardID"}, |
||||
) |
||||
|
||||
numFailedDownloadCounterVec = prometheus.NewCounterVec( |
||||
prometheus.CounterOpts{ |
||||
Namespace: "hmy", |
||||
Subsystem: "downloader", |
||||
Name: "failed_download", |
||||
Help: "number of downloading is failed", |
||||
}, |
||||
[]string{"ShardID", "error"}, |
||||
) |
||||
|
||||
numBlocksInsertedShortRangeHistogramVec = prometheus.NewHistogramVec( |
||||
prometheus.HistogramOpts{ |
||||
Namespace: "hmy", |
||||
Subsystem: "downloader", |
||||
Name: "num_blocks_inserted_short_range", |
||||
Help: "number of blocks inserted for each short range sync", |
||||
// Buckets: 0, 1, 2, 4, +INF (capped at 10)
|
||||
Buckets: prometheus.ExponentialBuckets(0.5, 2, 5), |
||||
}, |
||||
[]string{"ShardID"}, |
||||
) |
||||
|
||||
numBlocksInsertedBeaconHelperCounter = prometheus.NewCounter( |
||||
prometheus.CounterOpts{ |
||||
Namespace: "hmy", |
||||
Subsystem: "downloader", |
||||
Name: "num_blocks_inserted_beacon_helper", |
||||
Help: "number of blocks inserted from beacon helper", |
||||
}, |
||||
) |
||||
) |
||||
|
||||
func (d *Downloader) promLabels() prometheus.Labels { |
||||
sid := d.bc.ShardID() |
||||
return prometheus.Labels{"ShardID": fmt.Sprintf("%d", sid)} |
||||
} |
||||
@ -1,593 +0,0 @@ |
||||
package downloader |
||||
|
||||
import ( |
||||
"context" |
||||
"fmt" |
||||
"math" |
||||
"sync" |
||||
"time" |
||||
|
||||
"github.com/ethereum/go-ethereum/common" |
||||
"github.com/harmony-one/harmony/core" |
||||
"github.com/harmony-one/harmony/core/types" |
||||
syncProto "github.com/harmony-one/harmony/p2p/stream/protocols/sync" |
||||
sttypes "github.com/harmony-one/harmony/p2p/stream/types" |
||||
"github.com/harmony-one/harmony/shard" |
||||
"github.com/pkg/errors" |
||||
"github.com/rs/zerolog" |
||||
) |
||||
|
||||
// doShortRangeSync does the short range sync.
|
||||
// Compared with long range sync, short range sync is more focused on syncing to the latest block.
|
||||
// It consist of 3 steps:
|
||||
// 1. Obtain the block hashes and compute the longest hash chain..
|
||||
// 2. Get blocks by hashes from computed hash chain.
|
||||
// 3. Insert the blocks to blockchain.
|
||||
func (d *Downloader) doShortRangeSync() (int, error) { |
||||
if _, ok := d.bc.(*core.EpochChain); ok { |
||||
return d.doShortRangeSyncForEpochSync() |
||||
} |
||||
numShortRangeCounterVec.With(d.promLabels()).Inc() |
||||
|
||||
srCtx, cancel := context.WithTimeout(d.ctx, shortRangeTimeout) |
||||
defer cancel() |
||||
|
||||
sh := &srHelper{ |
||||
syncProtocol: d.syncProtocol, |
||||
ctx: srCtx, |
||||
config: d.config, |
||||
logger: d.logger.With().Str("mode", "short range").Logger(), |
||||
} |
||||
|
||||
if err := sh.checkPrerequisites(); err != nil { |
||||
return 0, errors.Wrap(err, "prerequisite") |
||||
} |
||||
curBN := d.bc.CurrentBlock().NumberU64() |
||||
hashChain, whitelist, err := sh.getHashChain(sh.prepareBlockHashNumbers(curBN)) |
||||
if err != nil { |
||||
return 0, errors.Wrap(err, "getHashChain") |
||||
} |
||||
if len(hashChain) == 0 { |
||||
// short circuit for no sync is needed
|
||||
return 0, nil |
||||
} |
||||
|
||||
expEndBN := curBN + uint64(len(hashChain)) |
||||
d.logger.Info().Uint64("current number", curBN). |
||||
Uint64("target number", expEndBN). |
||||
Interface("hashChain", hashChain). |
||||
Msg("short range start syncing") |
||||
d.startSyncing() |
||||
d.status.setTargetBN(expEndBN) |
||||
defer func() { |
||||
d.logger.Info().Msg("short range finished syncing") |
||||
d.finishSyncing() |
||||
}() |
||||
|
||||
blocks, stids, err := sh.getBlocksByHashes(hashChain, whitelist) |
||||
if err != nil { |
||||
d.logger.Warn().Err(err).Msg("getBlocksByHashes failed") |
||||
if !errors.Is(err, context.Canceled) { |
||||
sh.removeStreams(whitelist) // Remote nodes cannot provide blocks with target hashes
|
||||
} |
||||
return 0, errors.Wrap(err, "getBlocksByHashes") |
||||
} |
||||
d.logger.Info().Int("num blocks", len(blocks)).Msg("getBlockByHashes result") |
||||
|
||||
n, err := verifyAndInsertBlocks(d.bc, blocks) |
||||
numBlocksInsertedShortRangeHistogramVec.With(d.promLabels()).Observe(float64(n)) |
||||
if err != nil { |
||||
d.logger.Warn().Err(err).Int("blocks inserted", n).Msg("Insert block failed") |
||||
if sh.blameAllStreams(blocks, n, err) { |
||||
sh.removeStreams(whitelist) // Data provided by remote nodes is corrupted
|
||||
} else { |
||||
// It is the last block gives a wrong commit sig. Blame the provider of the last block.
|
||||
st2Blame := stids[len(stids)-1] |
||||
sh.removeStreams([]sttypes.StreamID{st2Blame}) |
||||
} |
||||
return n, err |
||||
} |
||||
d.logger.Info().Err(err).Int("blocks inserted", n).Msg("Insert block success") |
||||
|
||||
return len(blocks), nil |
||||
} |
||||
|
||||
func (d *Downloader) doShortRangeSyncForEpochSync() (int, error) { |
||||
numShortRangeCounterVec.With(d.promLabels()).Inc() |
||||
|
||||
srCtx, cancel := context.WithTimeout(d.ctx, shortRangeTimeout) |
||||
defer cancel() |
||||
|
||||
sh := &srHelper{ |
||||
syncProtocol: d.syncProtocol, |
||||
ctx: srCtx, |
||||
config: d.config, |
||||
logger: d.logger.With().Str("mode", "short range").Logger(), |
||||
} |
||||
|
||||
if err := sh.checkPrerequisites(); err != nil { |
||||
return 0, errors.Wrap(err, "prerequisite") |
||||
} |
||||
curBN := d.bc.CurrentBlock().NumberU64() |
||||
bns := make([]uint64, 0, numBlocksByNumPerRequest) |
||||
loopEpoch := d.bc.CurrentHeader().Epoch().Uint64() //+ 1
|
||||
for len(bns) < numBlocksByNumPerRequest { |
||||
blockNum := shard.Schedule.EpochLastBlock(loopEpoch) |
||||
if blockNum > curBN { |
||||
bns = append(bns, blockNum) |
||||
} |
||||
loopEpoch = loopEpoch + 1 |
||||
} |
||||
|
||||
if len(bns) == 0 { |
||||
return 0, nil |
||||
} |
||||
|
||||
blocks, streamID, err := sh.getBlocksChain(bns) |
||||
if err != nil { |
||||
return 0, errors.Wrap(err, "getHashChain") |
||||
} |
||||
if len(blocks) == 0 { |
||||
// short circuit for no sync is needed
|
||||
return 0, nil |
||||
} |
||||
n, err := d.bc.InsertChain(blocks, true) |
||||
numBlocksInsertedShortRangeHistogramVec.With(d.promLabels()).Observe(float64(n)) |
||||
if err != nil { |
||||
sh.removeStreams([]sttypes.StreamID{streamID}) // Data provided by remote nodes is corrupted
|
||||
return n, err |
||||
} |
||||
d.logger.Info().Err(err).Int("blocks inserted", n).Msg("Insert block success") |
||||
|
||||
return len(blocks), nil |
||||
} |
||||
|
||||
type srHelper struct { |
||||
syncProtocol syncProtocol |
||||
|
||||
ctx context.Context |
||||
config Config |
||||
logger zerolog.Logger |
||||
} |
||||
|
||||
func (sh *srHelper) getHashChain(bns []uint64) ([]common.Hash, []sttypes.StreamID, error) { |
||||
results := newBlockHashResults(bns) |
||||
|
||||
var wg sync.WaitGroup |
||||
wg.Add(sh.config.Concurrency) |
||||
|
||||
for i := 0; i != sh.config.Concurrency; i++ { |
||||
go func(index int) { |
||||
defer wg.Done() |
||||
|
||||
hashes, stid, err := sh.doGetBlockHashesRequest(bns) |
||||
if err != nil { |
||||
sh.logger.Warn().Err(err).Str("StreamID", string(stid)). |
||||
Msg("doGetBlockHashes return error") |
||||
return |
||||
} |
||||
sh.logger.Info(). |
||||
Str("StreamID", string(stid)). |
||||
Int("hashes", len(hashes)). |
||||
Interface("hashes", hashes).Int("index", index). |
||||
Msg("GetBlockHashesRequests response") |
||||
results.addResult(hashes, stid) |
||||
}(i) |
||||
} |
||||
wg.Wait() |
||||
|
||||
select { |
||||
case <-sh.ctx.Done(): |
||||
sh.logger.Info().Err(sh.ctx.Err()).Int("num blocks", results.numBlocksWithResults()). |
||||
Msg("short range sync get hashes timed out") |
||||
return nil, nil, sh.ctx.Err() |
||||
default: |
||||
} |
||||
|
||||
sh.logger.Info().Msg("compute longest hash chain") |
||||
hashChain, wl := results.computeLongestHashChain() |
||||
sh.logger.Info().Int("hashChain size", len(hashChain)).Int("whitelist", len(wl)). |
||||
Msg("computeLongestHashChain result") |
||||
return hashChain, wl, nil |
||||
} |
||||
|
||||
func (sh *srHelper) getBlocksChain(bns []uint64) ([]*types.Block, sttypes.StreamID, error) { |
||||
return sh.doGetBlocksByNumbersRequest(bns) |
||||
} |
||||
|
||||
func (sh *srHelper) getBlocksByHashes(hashes []common.Hash, whitelist []sttypes.StreamID) ([]*types.Block, []sttypes.StreamID, error) { |
||||
ctx, cancel := context.WithCancel(sh.ctx) |
||||
defer cancel() |
||||
m := newGetBlocksByHashManager(hashes, whitelist) |
||||
|
||||
var ( |
||||
wg sync.WaitGroup |
||||
gErr error |
||||
errLock sync.Mutex |
||||
) |
||||
|
||||
concurrency := sh.config.Concurrency |
||||
if concurrency > m.numRequests() { |
||||
concurrency = m.numRequests() |
||||
} |
||||
|
||||
wg.Add(concurrency) |
||||
for i := 0; i != concurrency; i++ { |
||||
go func(index int) { |
||||
defer wg.Done() |
||||
defer cancel() // it's ok to cancel context more than once
|
||||
|
||||
for { |
||||
if m.isDone() { |
||||
return |
||||
} |
||||
hashes, wl, err := m.getNextHashes() |
||||
if err != nil { |
||||
errLock.Lock() |
||||
gErr = err |
||||
errLock.Unlock() |
||||
return |
||||
} |
||||
if len(hashes) == 0 { |
||||
select { |
||||
case <-time.After(200 * time.Millisecond): |
||||
continue |
||||
case <-ctx.Done(): |
||||
return |
||||
} |
||||
} |
||||
blocks, stid, err := sh.doGetBlocksByHashesRequest(ctx, hashes, wl) |
||||
if err != nil { |
||||
sh.logger.Err(err).Str("StreamID", string(stid)).Msg("getBlocksByHashes worker failed") |
||||
m.handleResultError(hashes, stid) |
||||
} else { |
||||
sh.logger.Info().Str("StreamID", string(stid)).Int("blocks", len(blocks)). |
||||
Int("index", index).Msg("doGetBlocksByHashesRequest response") |
||||
m.addResult(hashes, blocks, stid) |
||||
} |
||||
} |
||||
}(i) |
||||
} |
||||
wg.Wait() |
||||
|
||||
if gErr != nil { |
||||
return nil, nil, gErr |
||||
} |
||||
select { |
||||
case <-sh.ctx.Done(): |
||||
res, _, _ := m.getResults() |
||||
sh.logger.Info().Err(sh.ctx.Err()).Int("num blocks", len(res)). |
||||
Msg("short range sync get blocks timed out") |
||||
return nil, nil, sh.ctx.Err() |
||||
default: |
||||
} |
||||
|
||||
return m.getResults() |
||||
} |
||||
|
||||
func (sh *srHelper) checkPrerequisites() error { |
||||
if sh.syncProtocol.NumStreams() < sh.config.Concurrency { |
||||
return errors.New("not enough streams") |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
func (sh *srHelper) prepareBlockHashNumbers(curNumber uint64) []uint64 { |
||||
res := make([]uint64, 0, numBlockHashesPerRequest) |
||||
|
||||
for bn := curNumber + 1; bn <= curNumber+uint64(numBlockHashesPerRequest); bn++ { |
||||
res = append(res, bn) |
||||
} |
||||
return res |
||||
} |
||||
|
||||
func (sh *srHelper) doGetBlockHashesRequest(bns []uint64) ([]common.Hash, sttypes.StreamID, error) { |
||||
ctx, cancel := context.WithTimeout(sh.ctx, 1*time.Second) |
||||
defer cancel() |
||||
|
||||
hashes, stid, err := sh.syncProtocol.GetBlockHashes(ctx, bns) |
||||
if err != nil { |
||||
sh.logger.Warn().Err(err).Str("stream", string(stid)).Msg("failed to doGetBlockHashesRequest") |
||||
return nil, stid, err |
||||
} |
||||
if len(hashes) != len(bns) { |
||||
err := errors.New("unexpected get block hashes result delivered") |
||||
sh.logger.Warn().Err(err).Str("stream", string(stid)).Msg("failed to doGetBlockHashesRequest") |
||||
sh.syncProtocol.RemoveStream(stid) |
||||
return nil, stid, err |
||||
} |
||||
return hashes, stid, nil |
||||
} |
||||
|
||||
func (sh *srHelper) doGetBlocksByNumbersRequest(bns []uint64) ([]*types.Block, sttypes.StreamID, error) { |
||||
ctx, cancel := context.WithTimeout(sh.ctx, 2*time.Second) |
||||
defer cancel() |
||||
|
||||
blocks, stid, err := sh.syncProtocol.GetBlocksByNumber(ctx, bns) |
||||
if err != nil { |
||||
sh.logger.Warn().Err(err).Str("stream", string(stid)).Msg("failed to doGetBlockHashesRequest") |
||||
return nil, stid, err |
||||
} |
||||
return blocks, stid, nil |
||||
} |
||||
|
||||
func (sh *srHelper) doGetBlocksByHashesRequest(ctx context.Context, hashes []common.Hash, wl []sttypes.StreamID) ([]*types.Block, sttypes.StreamID, error) { |
||||
ctx, cancel := context.WithTimeout(sh.ctx, 10*time.Second) |
||||
defer cancel() |
||||
|
||||
blocks, stid, err := sh.syncProtocol.GetBlocksByHashes(ctx, hashes, |
||||
syncProto.WithWhitelist(wl)) |
||||
if err != nil { |
||||
sh.logger.Warn().Err(err).Str("stream", string(stid)).Msg("failed to getBlockByHashes") |
||||
return nil, stid, err |
||||
} |
||||
if err := checkGetBlockByHashesResult(blocks, hashes); err != nil { |
||||
sh.logger.Warn().Err(err).Str("stream", string(stid)).Msg("failed to getBlockByHashes") |
||||
sh.syncProtocol.RemoveStream(stid) |
||||
return nil, stid, err |
||||
} |
||||
return blocks, stid, nil |
||||
} |
||||
|
||||
func (sh *srHelper) removeStreams(sts []sttypes.StreamID) { |
||||
for _, st := range sts { |
||||
sh.syncProtocol.RemoveStream(st) |
||||
} |
||||
} |
||||
|
||||
// Only not to blame all whitelisted streams when the it's not the last block signature verification failed.
|
||||
func (sh *srHelper) blameAllStreams(blocks types.Blocks, errIndex int, err error) bool { |
||||
if errors.As(err, &emptySigVerifyErr) && errIndex == len(blocks)-1 { |
||||
return false |
||||
} |
||||
return true |
||||
} |
||||
|
||||
func checkGetBlockByHashesResult(blocks []*types.Block, hashes []common.Hash) error { |
||||
if len(blocks) != len(hashes) { |
||||
return errors.New("unexpected number of getBlocksByHashes result") |
||||
} |
||||
for i, block := range blocks { |
||||
if block == nil { |
||||
return errors.New("nil block found") |
||||
} |
||||
if block.Hash() != hashes[i] { |
||||
return fmt.Errorf("unexpected block hash: %x / %x", block.Hash(), hashes[i]) |
||||
} |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
type ( |
||||
blockHashResults struct { |
||||
bns []uint64 |
||||
results []map[sttypes.StreamID]common.Hash |
||||
|
||||
lock sync.Mutex |
||||
} |
||||
) |
||||
|
||||
func newBlockHashResults(bns []uint64) *blockHashResults { |
||||
results := make([]map[sttypes.StreamID]common.Hash, 0, len(bns)) |
||||
for range bns { |
||||
results = append(results, make(map[sttypes.StreamID]common.Hash)) |
||||
} |
||||
return &blockHashResults{ |
||||
bns: bns, |
||||
results: results, |
||||
} |
||||
} |
||||
|
||||
func (res *blockHashResults) addResult(hashes []common.Hash, stid sttypes.StreamID) { |
||||
res.lock.Lock() |
||||
defer res.lock.Unlock() |
||||
|
||||
for i, h := range hashes { |
||||
if h == emptyHash { |
||||
return // nil block hash reached
|
||||
} |
||||
res.results[i][stid] = h |
||||
} |
||||
return |
||||
} |
||||
|
||||
func (res *blockHashResults) computeLongestHashChain() ([]common.Hash, []sttypes.StreamID) { |
||||
var ( |
||||
whitelist map[sttypes.StreamID]struct{} |
||||
hashChain []common.Hash |
||||
) |
||||
for _, result := range res.results { |
||||
hash, nextWl := countHashMaxVote(result, whitelist) |
||||
if hash == emptyHash { |
||||
break |
||||
} |
||||
hashChain = append(hashChain, hash) |
||||
whitelist = nextWl |
||||
} |
||||
|
||||
sts := make([]sttypes.StreamID, 0, len(whitelist)) |
||||
for st := range whitelist { |
||||
sts = append(sts, st) |
||||
} |
||||
return hashChain, sts |
||||
} |
||||
|
||||
func (res *blockHashResults) numBlocksWithResults() int { |
||||
res.lock.Lock() |
||||
defer res.lock.Unlock() |
||||
|
||||
cnt := 0 |
||||
for _, result := range res.results { |
||||
if len(result) != 0 { |
||||
cnt++ |
||||
} |
||||
} |
||||
return cnt |
||||
} |
||||
|
||||
func countHashMaxVote(m map[sttypes.StreamID]common.Hash, whitelist map[sttypes.StreamID]struct{}) (common.Hash, map[sttypes.StreamID]struct{}) { |
||||
var ( |
||||
voteM = make(map[common.Hash]int) |
||||
res common.Hash |
||||
maxCnt = 0 |
||||
) |
||||
|
||||
for st, h := range m { |
||||
if len(whitelist) != 0 { |
||||
if _, ok := whitelist[st]; !ok { |
||||
continue |
||||
} |
||||
} |
||||
if _, ok := voteM[h]; !ok { |
||||
voteM[h] = 0 |
||||
} |
||||
voteM[h]++ |
||||
if voteM[h] > maxCnt { |
||||
maxCnt = voteM[h] |
||||
res = h |
||||
} |
||||
} |
||||
|
||||
nextWl := make(map[sttypes.StreamID]struct{}) |
||||
for st, h := range m { |
||||
if h != res { |
||||
continue |
||||
} |
||||
if len(whitelist) != 0 { |
||||
if _, ok := whitelist[st]; ok { |
||||
nextWl[st] = struct{}{} |
||||
} |
||||
} else { |
||||
nextWl[st] = struct{}{} |
||||
} |
||||
} |
||||
return res, nextWl |
||||
} |
||||
|
||||
type getBlocksByHashManager struct { |
||||
hashes []common.Hash |
||||
pendings map[common.Hash]struct{} |
||||
results map[common.Hash]blockResult |
||||
whitelist []sttypes.StreamID |
||||
|
||||
lock sync.Mutex |
||||
} |
||||
|
||||
func newGetBlocksByHashManager(hashes []common.Hash, whitelist []sttypes.StreamID) *getBlocksByHashManager { |
||||
return &getBlocksByHashManager{ |
||||
hashes: hashes, |
||||
pendings: make(map[common.Hash]struct{}), |
||||
results: make(map[common.Hash]blockResult), |
||||
whitelist: whitelist, |
||||
} |
||||
} |
||||
|
||||
func (m *getBlocksByHashManager) getNextHashes() ([]common.Hash, []sttypes.StreamID, error) { |
||||
m.lock.Lock() |
||||
defer m.lock.Unlock() |
||||
|
||||
num := m.numBlocksPerRequest() |
||||
hashes := make([]common.Hash, 0, num) |
||||
if len(m.whitelist) == 0 { |
||||
return nil, nil, errors.New("empty white list") |
||||
} |
||||
|
||||
for _, hash := range m.hashes { |
||||
if len(hashes) == num { |
||||
break |
||||
} |
||||
_, ok1 := m.pendings[hash] |
||||
_, ok2 := m.results[hash] |
||||
if !ok1 && !ok2 { |
||||
hashes = append(hashes, hash) |
||||
} |
||||
} |
||||
sts := make([]sttypes.StreamID, len(m.whitelist)) |
||||
copy(sts, m.whitelist) |
||||
return hashes, sts, nil |
||||
} |
||||
|
||||
func (m *getBlocksByHashManager) numBlocksPerRequest() int { |
||||
val := divideCeil(len(m.hashes), len(m.whitelist)) |
||||
if val < numBlocksByHashesLowerCap { |
||||
val = numBlocksByHashesLowerCap |
||||
} |
||||
if val > numBlocksByHashesUpperCap { |
||||
val = numBlocksByHashesUpperCap |
||||
} |
||||
return val |
||||
} |
||||
|
||||
func (m *getBlocksByHashManager) numRequests() int { |
||||
return divideCeil(len(m.hashes), m.numBlocksPerRequest()) |
||||
} |
||||
|
||||
func (m *getBlocksByHashManager) addResult(hashes []common.Hash, blocks []*types.Block, stid sttypes.StreamID) { |
||||
m.lock.Lock() |
||||
defer m.lock.Unlock() |
||||
|
||||
for i, hash := range hashes { |
||||
block := blocks[i] |
||||
delete(m.pendings, hash) |
||||
m.results[hash] = blockResult{ |
||||
block: block, |
||||
stid: stid, |
||||
} |
||||
} |
||||
} |
||||
|
||||
func (m *getBlocksByHashManager) handleResultError(hashes []common.Hash, stid sttypes.StreamID) { |
||||
m.lock.Lock() |
||||
defer m.lock.Unlock() |
||||
|
||||
m.removeStreamID(stid) |
||||
|
||||
for _, hash := range hashes { |
||||
delete(m.pendings, hash) |
||||
} |
||||
} |
||||
|
||||
func (m *getBlocksByHashManager) getResults() ([]*types.Block, []sttypes.StreamID, error) { |
||||
m.lock.Lock() |
||||
defer m.lock.Unlock() |
||||
|
||||
blocks := make([]*types.Block, 0, len(m.hashes)) |
||||
stids := make([]sttypes.StreamID, 0, len(m.hashes)) |
||||
for _, hash := range m.hashes { |
||||
if m.results[hash].block == nil { |
||||
return nil, nil, errors.New("SANITY: nil block found") |
||||
} |
||||
blocks = append(blocks, m.results[hash].block) |
||||
stids = append(stids, m.results[hash].stid) |
||||
} |
||||
return blocks, stids, nil |
||||
} |
||||
|
||||
func (m *getBlocksByHashManager) isDone() bool { |
||||
m.lock.Lock() |
||||
defer m.lock.Unlock() |
||||
|
||||
return len(m.results) == len(m.hashes) |
||||
} |
||||
|
||||
func (m *getBlocksByHashManager) removeStreamID(target sttypes.StreamID) { |
||||
// O(n^2) complexity. But considering the whitelist size is small, should not
|
||||
// have performance issue.
|
||||
loop: |
||||
for i, stid := range m.whitelist { |
||||
if stid == target { |
||||
if i == len(m.whitelist) { |
||||
m.whitelist = m.whitelist[:i] |
||||
} else { |
||||
m.whitelist = append(m.whitelist[:i], m.whitelist[i+1:]...) |
||||
} |
||||
goto loop |
||||
} |
||||
} |
||||
return |
||||
} |
||||
|
||||
func divideCeil(x, y int) int { |
||||
fVal := float64(x) / float64(y) |
||||
return int(math.Ceil(fVal)) |
||||
} |
||||
@ -1,437 +0,0 @@ |
||||
package downloader |
||||
|
||||
import ( |
||||
"context" |
||||
"errors" |
||||
"fmt" |
||||
"sync" |
||||
"testing" |
||||
|
||||
"github.com/ethereum/go-ethereum/common" |
||||
sttypes "github.com/harmony-one/harmony/p2p/stream/types" |
||||
"github.com/rs/zerolog" |
||||
) |
||||
|
||||
func TestDownloader_doShortRangeSync(t *testing.T) { |
||||
chain := newTestBlockChain(100, nil) |
||||
|
||||
d := &Downloader{ |
||||
bc: chain, |
||||
syncProtocol: newTestSyncProtocol(105, 32, nil), |
||||
config: Config{ |
||||
Concurrency: 16, |
||||
MinStreams: 16, |
||||
}, |
||||
ctx: context.Background(), |
||||
logger: zerolog.Logger{}, |
||||
} |
||||
n, err := d.doShortRangeSync() |
||||
if err != nil { |
||||
t.Error(err) |
||||
} |
||||
if n == 0 { |
||||
t.Error("not synced") |
||||
} |
||||
if curNum := d.bc.CurrentBlock().NumberU64(); curNum != 105 { |
||||
t.Errorf("unexpected block number after sync: %v / %v", curNum, 105) |
||||
} |
||||
} |
||||
|
||||
func TestSrHelper_getHashChain(t *testing.T) { |
||||
tests := []struct { |
||||
curBN uint64 |
||||
syncProtocol syncProtocol |
||||
config Config |
||||
|
||||
expHashChainSize int |
||||
expStSize int |
||||
}{ |
||||
{ |
||||
curBN: 100, |
||||
syncProtocol: newTestSyncProtocol(1000, 32, nil), |
||||
config: Config{ |
||||
Concurrency: 16, |
||||
MinStreams: 16, |
||||
}, |
||||
expHashChainSize: numBlockHashesPerRequest, |
||||
expStSize: 16, // Concurrency
|
||||
}, |
||||
{ |
||||
curBN: 100, |
||||
syncProtocol: newTestSyncProtocol(100, 32, nil), |
||||
config: Config{ |
||||
Concurrency: 16, |
||||
MinStreams: 16, |
||||
}, |
||||
expHashChainSize: 0, |
||||
expStSize: 0, |
||||
}, |
||||
{ |
||||
curBN: 100, |
||||
syncProtocol: newTestSyncProtocol(110, 32, nil), |
||||
config: Config{ |
||||
Concurrency: 16, |
||||
MinStreams: 16, |
||||
}, |
||||
expHashChainSize: 10, |
||||
expStSize: 16, |
||||
}, |
||||
{ |
||||
// stream size is smaller than concurrency
|
||||
curBN: 100, |
||||
syncProtocol: newTestSyncProtocol(1000, 10, nil), |
||||
config: Config{ |
||||
Concurrency: 16, |
||||
MinStreams: 8, |
||||
}, |
||||
expHashChainSize: numBlockHashesPerRequest, |
||||
expStSize: 10, |
||||
}, |
||||
{ |
||||
// one stream reports an error, else are fine
|
||||
curBN: 100, |
||||
syncProtocol: newTestSyncProtocol(1000, 32, makeOnceErrorFunc()), |
||||
config: Config{ |
||||
Concurrency: 16, |
||||
MinStreams: 16, |
||||
}, |
||||
expHashChainSize: numBlockHashesPerRequest, |
||||
expStSize: 15, // Concurrency
|
||||
}, |
||||
{ |
||||
// error happens at one block number, all stream removed
|
||||
curBN: 100, |
||||
syncProtocol: newTestSyncProtocol(1000, 32, func(bn uint64) error { |
||||
if bn == 110 { |
||||
return errors.New("test error") |
||||
} |
||||
return nil |
||||
}), |
||||
config: Config{ |
||||
Concurrency: 16, |
||||
MinStreams: 16, |
||||
}, |
||||
expHashChainSize: 0, |
||||
expStSize: 0, |
||||
}, |
||||
{ |
||||
curBN: 100, |
||||
syncProtocol: newTestSyncProtocol(1000, 32, nil), |
||||
config: Config{ |
||||
Concurrency: 16, |
||||
MinStreams: 16, |
||||
}, |
||||
expHashChainSize: numBlockHashesPerRequest, |
||||
expStSize: 16, // Concurrency
|
||||
}, |
||||
} |
||||
|
||||
for i, test := range tests { |
||||
sh := &srHelper{ |
||||
syncProtocol: test.syncProtocol, |
||||
ctx: context.Background(), |
||||
config: test.config, |
||||
} |
||||
hashChain, wl, err := sh.getHashChain(sh.prepareBlockHashNumbers(test.curBN)) |
||||
if err != nil { |
||||
t.Error(err) |
||||
} |
||||
if len(hashChain) != test.expHashChainSize { |
||||
t.Errorf("Test %v: hash chain size unexpected: %v / %v", i, len(hashChain), test.expHashChainSize) |
||||
} |
||||
if len(wl) != test.expStSize { |
||||
t.Errorf("Test %v: whitelist size unexpected: %v / %v", i, len(wl), test.expStSize) |
||||
} |
||||
} |
||||
} |
||||
|
||||
func TestSrHelper_GetBlocksByHashes(t *testing.T) { |
||||
tests := []struct { |
||||
hashes []common.Hash |
||||
syncProtocol syncProtocol |
||||
config Config |
||||
|
||||
expBlockNumbers []uint64 |
||||
expErr error |
||||
}{ |
||||
{ |
||||
hashes: testNumberToHashes([]uint64{101, 102, 103, 104, 105, 106, 107, 108, 109, 110}), |
||||
syncProtocol: newTestSyncProtocol(1000, 32, nil), |
||||
config: Config{ |
||||
Concurrency: 16, |
||||
MinStreams: 16, |
||||
}, |
||||
expBlockNumbers: []uint64{101, 102, 103, 104, 105, 106, 107, 108, 109, 110}, |
||||
expErr: nil, |
||||
}, |
||||
{ |
||||
// remote node cannot give the block with the given hash
|
||||
hashes: testNumberToHashes([]uint64{101, 102, 103, 104, 105, 106, 107, 108, 109, 110}), |
||||
syncProtocol: newTestSyncProtocol(100, 32, nil), |
||||
config: Config{ |
||||
Concurrency: 16, |
||||
MinStreams: 16, |
||||
}, |
||||
expBlockNumbers: []uint64{}, |
||||
expErr: errors.New("all streams are bad"), |
||||
}, |
||||
{ |
||||
// one request return an error, else are fine
|
||||
hashes: testNumberToHashes([]uint64{101, 102, 103, 104, 105, 106, 107, 108, 109, 110}), |
||||
syncProtocol: newTestSyncProtocol(1000, 32, makeOnceErrorFunc()), |
||||
config: Config{ |
||||
Concurrency: 16, |
||||
MinStreams: 16, |
||||
}, |
||||
expBlockNumbers: []uint64{101, 102, 103, 104, 105, 106, 107, 108, 109, 110}, |
||||
expErr: nil, |
||||
}, |
||||
{ |
||||
// All nodes encounter an error
|
||||
hashes: testNumberToHashes([]uint64{101, 102, 103, 104, 105, 106, 107, 108, 109, 110}), |
||||
syncProtocol: newTestSyncProtocol(1000, 32, func(n uint64) error { |
||||
if n == 109 { |
||||
return errors.New("test error") |
||||
} |
||||
return nil |
||||
}), |
||||
config: Config{ |
||||
Concurrency: 16, |
||||
MinStreams: 16, |
||||
}, |
||||
expErr: errors.New("error expected"), |
||||
}, |
||||
} |
||||
for i, test := range tests { |
||||
sh := &srHelper{ |
||||
syncProtocol: test.syncProtocol, |
||||
ctx: context.Background(), |
||||
config: test.config, |
||||
} |
||||
blocks, _, err := sh.getBlocksByHashes(test.hashes, makeStreamIDs(5)) |
||||
if (err == nil) != (test.expErr == nil) { |
||||
t.Errorf("Test %v: unexpected error %v / %v", i, err, test.expErr) |
||||
} |
||||
if len(blocks) != len(test.expBlockNumbers) { |
||||
t.Errorf("Test %v: unepxected block number size: %v / %v", i, len(blocks), len(test.expBlockNumbers)) |
||||
} |
||||
for i, block := range blocks { |
||||
gotNum := testHashToNumber(block.Hash()) |
||||
if gotNum != test.expBlockNumbers[i] { |
||||
t.Errorf("Test %v: unexpected block number", i) |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
func TestBlockHashResult_ComputeLongestHashChain(t *testing.T) { |
||||
tests := []struct { |
||||
bns []uint64 |
||||
results map[sttypes.StreamID][]int64 |
||||
expChain []uint64 |
||||
expWhitelist map[sttypes.StreamID]struct{} |
||||
expErr error |
||||
}{ |
||||
{ |
||||
bns: []uint64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, |
||||
results: map[sttypes.StreamID][]int64{ |
||||
makeStreamID(0): {1, 2, 3, 4, 5, 6, 7}, |
||||
makeStreamID(1): {1, 2, 3, 4, 5, 6, 7}, |
||||
makeStreamID(2): {1, 2, 3, 4, 5}, // left behind
|
||||
}, |
||||
expChain: []uint64{1, 2, 3, 4, 5, 6, 7}, |
||||
expWhitelist: map[sttypes.StreamID]struct{}{ |
||||
makeStreamID(0): {}, |
||||
makeStreamID(1): {}, |
||||
}, |
||||
}, |
||||
{ |
||||
// minority fork
|
||||
bns: []uint64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, |
||||
results: map[sttypes.StreamID][]int64{ |
||||
makeStreamID(0): {1, 2, 3, 4, 5, 6, 7}, |
||||
makeStreamID(1): {1, 2, 3, 4, 5, 6, 7}, |
||||
makeStreamID(2): {1, 2, 3, 4, 5, 7, 8, 9}, |
||||
}, |
||||
expChain: []uint64{1, 2, 3, 4, 5, 6, 7}, |
||||
expWhitelist: map[sttypes.StreamID]struct{}{ |
||||
makeStreamID(0): {}, |
||||
makeStreamID(1): {}, |
||||
}, |
||||
}, { |
||||
// nil block
|
||||
bns: []uint64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, |
||||
results: map[sttypes.StreamID][]int64{ |
||||
makeStreamID(0): {}, |
||||
makeStreamID(1): {}, |
||||
makeStreamID(2): {}, |
||||
}, |
||||
expChain: nil, |
||||
expWhitelist: nil, |
||||
}, { |
||||
// not continuous block
|
||||
bns: []uint64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, |
||||
results: map[sttypes.StreamID][]int64{ |
||||
makeStreamID(0): {1, 2, 3, 4, 5, 6, 7, -1, 9}, |
||||
makeStreamID(1): {1, 2, 3, 4, 5, 6, 7}, |
||||
makeStreamID(2): {1, 2, 3, 4, 5, 7, 8, 9}, |
||||
}, |
||||
expChain: []uint64{1, 2, 3, 4, 5, 6, 7}, |
||||
expWhitelist: map[sttypes.StreamID]struct{}{ |
||||
makeStreamID(0): {}, |
||||
makeStreamID(1): {}, |
||||
}, |
||||
}, |
||||
{ |
||||
// not continuous block
|
||||
bns: []uint64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, |
||||
results: map[sttypes.StreamID][]int64{}, |
||||
expErr: errors.New("zero result"), |
||||
}, |
||||
} |
||||
|
||||
for i, test := range tests { |
||||
res := newBlockHashResults(test.bns) |
||||
for st, hs := range test.results { |
||||
res.addResult(makeTestBlockHashes(hs), st) |
||||
} |
||||
|
||||
chain, wl := res.computeLongestHashChain() |
||||
|
||||
if err := checkHashChainResult(chain, test.expChain); err != nil { |
||||
t.Errorf("Test %v: %v", i, err) |
||||
} |
||||
if err := checkStreamSetEqual(streamIDListToMap(wl), test.expWhitelist); err != nil { |
||||
t.Errorf("Test %v: %v", i, err) |
||||
} |
||||
} |
||||
} |
||||
|
||||
func checkHashChainResult(gots []common.Hash, exps []uint64) error { |
||||
if len(gots) != len(exps) { |
||||
return errors.New("unexpected size") |
||||
} |
||||
for i, got := range gots { |
||||
exp := exps[i] |
||||
if got != makeTestBlockHash(exp) { |
||||
return errors.New("unexpected block hash") |
||||
} |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
func TestHashMaxVote(t *testing.T) { |
||||
tests := []struct { |
||||
m map[sttypes.StreamID]common.Hash |
||||
whitelist map[sttypes.StreamID]struct{} |
||||
expRes common.Hash |
||||
expWhitelist map[sttypes.StreamID]struct{} |
||||
}{ |
||||
{ |
||||
m: map[sttypes.StreamID]common.Hash{ |
||||
makeStreamID(0): makeTestBlockHash(0), |
||||
makeStreamID(1): makeTestBlockHash(1), |
||||
makeStreamID(2): makeTestBlockHash(1), |
||||
}, |
||||
whitelist: map[sttypes.StreamID]struct{}{ |
||||
makeStreamID(0): {}, |
||||
makeStreamID(1): {}, |
||||
makeStreamID(2): {}, |
||||
}, |
||||
expRes: makeTestBlockHash(1), |
||||
expWhitelist: map[sttypes.StreamID]struct{}{ |
||||
makeStreamID(1): {}, |
||||
makeStreamID(2): {}, |
||||
}, |
||||
}, { |
||||
m: map[sttypes.StreamID]common.Hash{ |
||||
makeStreamID(0): makeTestBlockHash(0), |
||||
makeStreamID(1): makeTestBlockHash(1), |
||||
makeStreamID(2): makeTestBlockHash(1), |
||||
}, |
||||
whitelist: nil, |
||||
expRes: makeTestBlockHash(1), |
||||
expWhitelist: map[sttypes.StreamID]struct{}{ |
||||
makeStreamID(1): {}, |
||||
makeStreamID(2): {}, |
||||
}, |
||||
}, { |
||||
m: map[sttypes.StreamID]common.Hash{ |
||||
makeStreamID(0): makeTestBlockHash(0), |
||||
makeStreamID(1): makeTestBlockHash(1), |
||||
makeStreamID(2): makeTestBlockHash(1), |
||||
makeStreamID(3): makeTestBlockHash(0), |
||||
makeStreamID(4): makeTestBlockHash(0), |
||||
}, |
||||
whitelist: map[sttypes.StreamID]struct{}{ |
||||
makeStreamID(0): {}, |
||||
makeStreamID(1): {}, |
||||
makeStreamID(2): {}, |
||||
}, |
||||
expRes: makeTestBlockHash(1), |
||||
expWhitelist: map[sttypes.StreamID]struct{}{ |
||||
makeStreamID(1): {}, |
||||
makeStreamID(2): {}, |
||||
}, |
||||
}, |
||||
} |
||||
|
||||
for i, test := range tests { |
||||
h, wl := countHashMaxVote(test.m, test.whitelist) |
||||
|
||||
if h != test.expRes { |
||||
t.Errorf("Test %v: unexpected hash: %x / %x", i, h, test.expRes) |
||||
} |
||||
if err := checkStreamSetEqual(wl, test.expWhitelist); err != nil { |
||||
t.Errorf("Test %v: %v", i, err) |
||||
} |
||||
} |
||||
} |
||||
|
||||
func checkStreamSetEqual(m1, m2 map[sttypes.StreamID]struct{}) error { |
||||
if len(m1) != len(m2) { |
||||
return fmt.Errorf("unexpected size: %v / %v", len(m1), len(m2)) |
||||
} |
||||
for st := range m1 { |
||||
if _, ok := m2[st]; !ok { |
||||
return errors.New("not equal") |
||||
} |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
func makeTestBlockHashes(bns []int64) []common.Hash { |
||||
hs := make([]common.Hash, 0, len(bns)) |
||||
for _, bn := range bns { |
||||
if bn < 0 { |
||||
hs = append(hs, emptyHash) |
||||
} else { |
||||
hs = append(hs, makeTestBlockHash(uint64(bn))) |
||||
} |
||||
} |
||||
return hs |
||||
} |
||||
|
||||
func streamIDListToMap(sts []sttypes.StreamID) map[sttypes.StreamID]struct{} { |
||||
res := make(map[sttypes.StreamID]struct{}) |
||||
|
||||
for _, st := range sts { |
||||
res[st] = struct{}{} |
||||
} |
||||
return res |
||||
} |
||||
|
||||
func makeTestBlockHash(bn uint64) common.Hash { |
||||
return makeTestBlock(bn).Hash() |
||||
} |
||||
|
||||
func makeOnceErrorFunc() func(num uint64) error { |
||||
var once sync.Once |
||||
return func(num uint64) error { |
||||
var err error |
||||
once.Do(func() { |
||||
err = errors.New("test error expected") |
||||
}) |
||||
return err |
||||
} |
||||
} |
||||
@ -1,292 +0,0 @@ |
||||
package downloader |
||||
|
||||
import ( |
||||
"container/heap" |
||||
"sync" |
||||
|
||||
"github.com/ethereum/go-ethereum/common" |
||||
"github.com/harmony-one/harmony/core/types" |
||||
sttypes "github.com/harmony-one/harmony/p2p/stream/types" |
||||
) |
||||
|
||||
var ( |
||||
emptyHash common.Hash |
||||
) |
||||
|
||||
type status struct { |
||||
isSyncing bool |
||||
targetBN uint64 |
||||
lock sync.Mutex |
||||
} |
||||
|
||||
func newStatus() status { |
||||
return status{} |
||||
} |
||||
|
||||
func (s *status) startSyncing() { |
||||
s.lock.Lock() |
||||
defer s.lock.Unlock() |
||||
|
||||
s.isSyncing = true |
||||
} |
||||
|
||||
func (s *status) setTargetBN(val uint64) { |
||||
s.lock.Lock() |
||||
defer s.lock.Unlock() |
||||
|
||||
s.targetBN = val |
||||
} |
||||
|
||||
func (s *status) finishSyncing() { |
||||
s.lock.Lock() |
||||
defer s.lock.Unlock() |
||||
|
||||
s.isSyncing = false |
||||
s.targetBN = 0 |
||||
} |
||||
|
||||
func (s *status) get() (bool, uint64) { |
||||
s.lock.Lock() |
||||
defer s.lock.Unlock() |
||||
|
||||
return s.isSyncing, s.targetBN |
||||
} |
||||
|
||||
type getBlocksResult struct { |
||||
bns []uint64 |
||||
blocks []*types.Block |
||||
stid sttypes.StreamID |
||||
} |
||||
|
||||
type resultQueue struct { |
||||
results *priorityQueue |
||||
lock sync.Mutex |
||||
} |
||||
|
||||
func newResultQueue() *resultQueue { |
||||
pq := make(priorityQueue, 0, 200) // 200 - rough estimate
|
||||
heap.Init(&pq) |
||||
return &resultQueue{ |
||||
results: &pq, |
||||
} |
||||
} |
||||
|
||||
// addBlockResults adds the blocks to the result queue to be processed by insertChainLoop.
|
||||
// If a nil block is detected in the block list, will not process further blocks.
|
||||
func (rq *resultQueue) addBlockResults(blocks []*types.Block, stid sttypes.StreamID) { |
||||
rq.lock.Lock() |
||||
defer rq.lock.Unlock() |
||||
|
||||
for _, block := range blocks { |
||||
if block == nil { |
||||
continue |
||||
} |
||||
heap.Push(rq.results, &blockResult{ |
||||
block: block, |
||||
stid: stid, |
||||
}) |
||||
} |
||||
return |
||||
} |
||||
|
||||
// popBlockResults pop a continuous list of blocks starting at expStartBN with capped size.
|
||||
// Return the stale block numbers as the second return value
|
||||
func (rq *resultQueue) popBlockResults(expStartBN uint64, cap int) ([]*blockResult, []uint64) { |
||||
rq.lock.Lock() |
||||
defer rq.lock.Unlock() |
||||
|
||||
var ( |
||||
res = make([]*blockResult, 0, cap) |
||||
stales []uint64 |
||||
) |
||||
|
||||
for cnt := 0; rq.results.Len() > 0 && cnt < cap; cnt++ { |
||||
br := heap.Pop(rq.results).(*blockResult) |
||||
// stale block number
|
||||
if br.block.NumberU64() < expStartBN { |
||||
stales = append(stales, br.block.NumberU64()) |
||||
continue |
||||
} |
||||
if br.block.NumberU64() != expStartBN { |
||||
heap.Push(rq.results, br) |
||||
return res, stales |
||||
} |
||||
res = append(res, br) |
||||
expStartBN++ |
||||
} |
||||
return res, stales |
||||
} |
||||
|
||||
// removeResultsByStreamID remove the block results of the given stream, return the block
|
||||
// number removed from the queue
|
||||
func (rq *resultQueue) removeResultsByStreamID(stid sttypes.StreamID) []uint64 { |
||||
rq.lock.Lock() |
||||
defer rq.lock.Unlock() |
||||
|
||||
var removed []uint64 |
||||
|
||||
Loop: |
||||
for { |
||||
for i, res := range *rq.results { |
||||
blockRes := res.(*blockResult) |
||||
if blockRes.stid == stid { |
||||
rq.removeByIndex(i) |
||||
removed = append(removed, blockRes.block.NumberU64()) |
||||
goto Loop |
||||
} |
||||
} |
||||
break |
||||
} |
||||
return removed |
||||
} |
||||
|
||||
func (rq *resultQueue) length() int { |
||||
return len(*rq.results) |
||||
} |
||||
|
||||
func (rq *resultQueue) removeByIndex(index int) { |
||||
heap.Remove(rq.results, index) |
||||
} |
||||
|
||||
// bnPrioritizedItem is the item which uses block number to determine its priority
|
||||
type bnPrioritizedItem interface { |
||||
getBlockNumber() uint64 |
||||
} |
||||
|
||||
type blockResult struct { |
||||
block *types.Block |
||||
stid sttypes.StreamID |
||||
} |
||||
|
||||
func (br *blockResult) getBlockNumber() uint64 { |
||||
return br.block.NumberU64() |
||||
} |
||||
|
||||
func blockResultsToBlocks(results []*blockResult) []*types.Block { |
||||
blocks := make([]*types.Block, 0, len(results)) |
||||
|
||||
for _, result := range results { |
||||
blocks = append(blocks, result.block) |
||||
} |
||||
return blocks |
||||
} |
||||
|
||||
type ( |
||||
prioritizedNumber uint64 |
||||
|
||||
prioritizedNumbers struct { |
||||
q *priorityQueue |
||||
} |
||||
) |
||||
|
||||
func (b prioritizedNumber) getBlockNumber() uint64 { |
||||
return uint64(b) |
||||
} |
||||
|
||||
func newPrioritizedNumbers() *prioritizedNumbers { |
||||
pqs := make(priorityQueue, 0) |
||||
heap.Init(&pqs) |
||||
return &prioritizedNumbers{ |
||||
q: &pqs, |
||||
} |
||||
} |
||||
|
||||
func (pbs *prioritizedNumbers) push(bn uint64) { |
||||
heap.Push(pbs.q, prioritizedNumber(bn)) |
||||
} |
||||
|
||||
func (pbs *prioritizedNumbers) pop() uint64 { |
||||
if pbs.q.Len() == 0 { |
||||
return 0 |
||||
} |
||||
item := heap.Pop(pbs.q) |
||||
return uint64(item.(prioritizedNumber)) |
||||
} |
||||
|
||||
func (pbs *prioritizedNumbers) length() int { |
||||
return len(*pbs.q) |
||||
} |
||||
|
||||
type ( |
||||
blockByNumber types.Block |
||||
|
||||
// blocksByNumber is the priority queue ordered by number
|
||||
blocksByNumber struct { |
||||
q *priorityQueue |
||||
cap int |
||||
} |
||||
) |
||||
|
||||
func (b *blockByNumber) getBlockNumber() uint64 { |
||||
raw := (*types.Block)(b) |
||||
return raw.NumberU64() |
||||
} |
||||
|
||||
func newBlocksByNumber(cap int) *blocksByNumber { |
||||
pqs := make(priorityQueue, 0) |
||||
heap.Init(&pqs) |
||||
return &blocksByNumber{ |
||||
q: &pqs, |
||||
cap: cap, |
||||
} |
||||
} |
||||
|
||||
func (bs *blocksByNumber) push(b *types.Block) { |
||||
heap.Push(bs.q, (*blockByNumber)(b)) |
||||
for bs.q.Len() > bs.cap { |
||||
heap.Pop(bs.q) |
||||
} |
||||
} |
||||
|
||||
func (bs *blocksByNumber) pop() *types.Block { |
||||
if bs.q.Len() == 0 { |
||||
return nil |
||||
} |
||||
item := heap.Pop(bs.q) |
||||
return (*types.Block)(item.(*blockByNumber)) |
||||
} |
||||
|
||||
func (bs *blocksByNumber) len() int { |
||||
return bs.q.Len() |
||||
} |
||||
|
||||
// priorityQueue is a priorityQueue with lowest block number with highest priority
|
||||
type priorityQueue []bnPrioritizedItem |
||||
|
||||
// resultQueue implements heap interface
|
||||
func (q priorityQueue) Len() int { |
||||
return len(q) |
||||
} |
||||
|
||||
// resultQueue implements heap interface
|
||||
func (q priorityQueue) Less(i, j int) bool { |
||||
bn1 := q[i].getBlockNumber() |
||||
bn2 := q[j].getBlockNumber() |
||||
return bn1 < bn2 // small block number has higher priority
|
||||
} |
||||
|
||||
// resultQueue implements heap interface
|
||||
func (q priorityQueue) Swap(i, j int) { |
||||
q[i], q[j] = q[j], q[i] |
||||
} |
||||
|
||||
// resultQueue implements heap interface
|
||||
func (q *priorityQueue) Push(x interface{}) { |
||||
item, ok := x.(bnPrioritizedItem) |
||||
if !ok { |
||||
panic("wrong type of getBlockNumber interface") |
||||
} |
||||
*q = append(*q, item) |
||||
} |
||||
|
||||
// resultQueue implements heap interface
|
||||
func (q *priorityQueue) Pop() interface{} { |
||||
prev := *q |
||||
n := len(prev) |
||||
if n == 0 { |
||||
return nil |
||||
} |
||||
res := prev[n-1] |
||||
*q = prev[0 : n-1] |
||||
return res |
||||
} |
||||
@ -1,266 +0,0 @@ |
||||
package downloader |
||||
|
||||
import ( |
||||
"container/heap" |
||||
"fmt" |
||||
"math/big" |
||||
"strings" |
||||
"testing" |
||||
|
||||
"github.com/harmony-one/harmony/block" |
||||
headerV3 "github.com/harmony-one/harmony/block/v3" |
||||
"github.com/harmony-one/harmony/core/types" |
||||
bls_cosi "github.com/harmony-one/harmony/crypto/bls" |
||||
sttypes "github.com/harmony-one/harmony/p2p/stream/types" |
||||
) |
||||
|
||||
func TestResultQueue_AddBlockResults(t *testing.T) { |
||||
tests := []struct { |
||||
initBNs []uint64 |
||||
addBNs []uint64 |
||||
expSize int |
||||
}{ |
||||
{ |
||||
initBNs: []uint64{}, |
||||
addBNs: []uint64{1, 2, 3, 4}, |
||||
expSize: 4, |
||||
}, |
||||
{ |
||||
initBNs: []uint64{1, 2, 3, 4}, |
||||
addBNs: []uint64{5, 6, 7, 8}, |
||||
expSize: 8, |
||||
}, |
||||
} |
||||
for i, test := range tests { |
||||
rq := makeTestResultQueue(test.initBNs) |
||||
rq.addBlockResults(makeTestBlocks(test.addBNs), "") |
||||
|
||||
if rq.results.Len() != test.expSize { |
||||
t.Errorf("Test %v: unexpected size: %v / %v", i, rq.results.Len(), test.expSize) |
||||
} |
||||
} |
||||
} |
||||
|
||||
func TestResultQueue_PopBlockResults(t *testing.T) { |
||||
tests := []struct { |
||||
initBNs []uint64 |
||||
cap int |
||||
expStart uint64 |
||||
expSize int |
||||
staleSize int |
||||
}{ |
||||
{ |
||||
initBNs: []uint64{1, 2, 3, 4, 5}, |
||||
cap: 3, |
||||
expStart: 1, |
||||
expSize: 3, |
||||
staleSize: 0, |
||||
}, |
||||
{ |
||||
initBNs: []uint64{1, 2, 3, 4, 5}, |
||||
cap: 10, |
||||
expStart: 1, |
||||
expSize: 5, |
||||
staleSize: 0, |
||||
}, |
||||
{ |
||||
initBNs: []uint64{1, 3, 4, 5}, |
||||
cap: 10, |
||||
expStart: 1, |
||||
expSize: 1, |
||||
staleSize: 0, |
||||
}, |
||||
{ |
||||
initBNs: []uint64{1, 2, 3, 4, 5}, |
||||
cap: 10, |
||||
expStart: 0, |
||||
expSize: 0, |
||||
staleSize: 0, |
||||
}, |
||||
{ |
||||
initBNs: []uint64{1, 1, 1, 1, 2}, |
||||
cap: 10, |
||||
expStart: 1, |
||||
expSize: 2, |
||||
staleSize: 3, |
||||
}, |
||||
{ |
||||
initBNs: []uint64{1, 2, 3, 4, 5}, |
||||
cap: 10, |
||||
expStart: 2, |
||||
expSize: 4, |
||||
staleSize: 1, |
||||
}, |
||||
} |
||||
for i, test := range tests { |
||||
rq := makeTestResultQueue(test.initBNs) |
||||
res, stales := rq.popBlockResults(test.expStart, test.cap) |
||||
if len(res) != test.expSize { |
||||
t.Errorf("Test %v: unexpect size %v / %v", i, len(res), test.expSize) |
||||
} |
||||
if len(stales) != test.staleSize { |
||||
t.Errorf("Test %v: unexpect stale size %v / %v", i, len(stales), test.staleSize) |
||||
} |
||||
} |
||||
} |
||||
|
||||
func TestResultQueue_RemoveResultsByStreamID(t *testing.T) { |
||||
tests := []struct { |
||||
rq *resultQueue |
||||
rmStreamID sttypes.StreamID |
||||
removed int |
||||
expSize int |
||||
}{ |
||||
{ |
||||
rq: makeTestResultQueue([]uint64{1, 2, 3, 4}), |
||||
rmStreamID: "test stream id", |
||||
removed: 4, |
||||
expSize: 0, |
||||
}, |
||||
{ |
||||
rq: func() *resultQueue { |
||||
rq := makeTestResultQueue([]uint64{2, 3, 4, 5}) |
||||
rq.addBlockResults([]*types.Block{ |
||||
makeTestBlock(1), |
||||
makeTestBlock(5), |
||||
makeTestBlock(6), |
||||
}, "another test stream id") |
||||
return rq |
||||
}(), |
||||
rmStreamID: "test stream id", |
||||
removed: 4, |
||||
expSize: 3, |
||||
}, |
||||
{ |
||||
rq: func() *resultQueue { |
||||
rq := makeTestResultQueue([]uint64{2, 3, 4, 5}) |
||||
rq.addBlockResults([]*types.Block{ |
||||
makeTestBlock(1), |
||||
makeTestBlock(5), |
||||
makeTestBlock(6), |
||||
}, "another test stream id") |
||||
return rq |
||||
}(), |
||||
rmStreamID: "another test stream id", |
||||
removed: 3, |
||||
expSize: 4, |
||||
}, |
||||
} |
||||
for i, test := range tests { |
||||
res := test.rq.removeResultsByStreamID(test.rmStreamID) |
||||
if len(res) != test.removed { |
||||
t.Errorf("Test %v: unexpected number removed %v / %v", i, len(res), test.removed) |
||||
} |
||||
if gotSize := test.rq.results.Len(); gotSize != test.expSize { |
||||
t.Errorf("Test %v: unexpected number after removal %v / %v", i, gotSize, test.expSize) |
||||
} |
||||
} |
||||
} |
||||
|
||||
func makeTestResultQueue(bns []uint64) *resultQueue { |
||||
rq := newResultQueue() |
||||
for _, bn := range bns { |
||||
heap.Push(rq.results, &blockResult{ |
||||
block: makeTestBlock(bn), |
||||
stid: "test stream id", |
||||
}) |
||||
} |
||||
return rq |
||||
} |
||||
|
||||
func TestPrioritizedBlocks(t *testing.T) { |
||||
addBNs := []uint64{4, 7, 6, 9} |
||||
|
||||
bns := newPrioritizedNumbers() |
||||
for _, bn := range addBNs { |
||||
bns.push(bn) |
||||
} |
||||
prevBN := uint64(0) |
||||
for len(*bns.q) > 0 { |
||||
b := bns.pop() |
||||
if b < prevBN { |
||||
t.Errorf("number not incrementing") |
||||
} |
||||
prevBN = b |
||||
} |
||||
if last := bns.pop(); last != 0 { |
||||
t.Errorf("last elem is not 0") |
||||
} |
||||
} |
||||
|
||||
func TestBlocksByNumber(t *testing.T) { |
||||
addBNs := []uint64{4, 7, 6, 9} |
||||
|
||||
bns := newBlocksByNumber(10) |
||||
for _, bn := range addBNs { |
||||
bns.push(makeTestBlock(bn)) |
||||
} |
||||
if bns.len() != len(addBNs) { |
||||
t.Errorf("size unexpected: %v / %v", bns.len(), len(addBNs)) |
||||
} |
||||
prevBN := uint64(0) |
||||
for len(*bns.q) > 0 { |
||||
b := bns.pop() |
||||
if b.NumberU64() < prevBN { |
||||
t.Errorf("number not incrementing") |
||||
} |
||||
prevBN = b.NumberU64() |
||||
} |
||||
if lastBlock := bns.pop(); lastBlock != nil { |
||||
t.Errorf("last block is not nil") |
||||
} |
||||
} |
||||
|
||||
func TestPriorityQueue(t *testing.T) { |
||||
testBNs := []uint64{1, 9, 2, 4, 5, 12} |
||||
pq := make(priorityQueue, 0, 10) |
||||
heap.Init(&pq) |
||||
for _, bn := range testBNs { |
||||
heap.Push(&pq, &blockResult{ |
||||
block: makeTestBlock(bn), |
||||
stid: "", |
||||
}) |
||||
} |
||||
cmpBN := uint64(0) |
||||
for pq.Len() > 0 { |
||||
bn := heap.Pop(&pq).(*blockResult).block.NumberU64() |
||||
if bn < cmpBN { |
||||
t.Errorf("not incrementing") |
||||
} |
||||
cmpBN = bn |
||||
} |
||||
if pq.Len() != 0 { |
||||
t.Errorf("after poping, size not 0") |
||||
} |
||||
} |
||||
|
||||
func makeTestBlocks(bns []uint64) []*types.Block { |
||||
blocks := make([]*types.Block, 0, len(bns)) |
||||
for _, bn := range bns { |
||||
blocks = append(blocks, makeTestBlock(bn)) |
||||
} |
||||
return blocks |
||||
} |
||||
|
||||
func makeTestBlock(bn uint64) *types.Block { |
||||
testHeader := &block.Header{Header: headerV3.NewHeader()} |
||||
testHeader.SetNumber(big.NewInt(int64(bn))) |
||||
testHeader.SetLastCommitSignature(bls_cosi.SerializedSignature{}) |
||||
testHeader.SetLastCommitBitmap(make([]byte, 10)) |
||||
block := types.NewBlockWithHeader(testHeader) |
||||
block.SetCurrentCommitSig(make([]byte, 106)) |
||||
return block |
||||
} |
||||
|
||||
func assertError(got, expect error) error { |
||||
if (got == nil) != (expect == nil) { |
||||
return fmt.Errorf("unexpected error [%v] / [%v]", got, expect) |
||||
} |
||||
if (got == nil) || (expect == nil) { |
||||
return nil |
||||
} |
||||
if !strings.Contains(got.Error(), expect.Error()) { |
||||
return fmt.Errorf("unexpected error [%v] / [%v]", got, expect) |
||||
} |
||||
return nil |
||||
} |
||||
Loading…
Reference in new issue