"errors"
"math/rand"
"net"
+ "time"
- wire "github.com/tendermint/go-wire"
+ "github.com/tendermint/go-wire"
"github.com/tendermint/tmlibs/flowrate"
+ dbm "github.com/vapor/database/leveldb"
"github.com/vapor/consensus"
"github.com/vapor/netsync/peers"
flag consensus.ServiceFlag
srcPeer *P2PPeer
- remoteNode *ChainManager
+ remoteNode *Manager
msgCh chan []byte
async bool
}
return false
}
+func (p *P2PPeer) RemoteAddrHost() string {
+ return ""
+}
+
func (p *P2PPeer) ServiceFlag() consensus.ServiceFlag {
return p.flag
}
-func (p *P2PPeer) SetConnection(srcPeer *P2PPeer, node *ChainManager) {
+func (p *P2PPeer) SetConnection(srcPeer *P2PPeer, node *Manager) {
p.srcPeer = srcPeer
p.remoteNode = node
}
func (p *P2PPeer) postMan() {
for msgBytes := range p.msgCh {
msgType, msg, _ := decodeMessage(msgBytes)
+ time.Sleep(10 * time.Millisecond)
p.remoteNode.processMsg(p.srcPeer, msgType, msg)
}
}
return &PeerSet{}
}
-func (ps *PeerSet) AddBannedPeer(string) error { return nil }
-func (ps *PeerSet) StopPeerGracefully(string) {}
+func (ps *PeerSet) IsBanned(ip string, level byte, reason string) bool {
+ return false
+}
+
+func (ps *PeerSet) StopPeerGracefully(string) {}
type NetWork struct {
- nodes map[*ChainManager]P2PPeer
+ nodes map[*Manager]P2PPeer
}
func NewNetWork() *NetWork {
- return &NetWork{map[*ChainManager]P2PPeer{}}
+ return &NetWork{map[*Manager]P2PPeer{}}
}
-func (nw *NetWork) Register(node *ChainManager, addr, id string, flag consensus.ServiceFlag) {
+func (nw *NetWork) Register(node *Manager, addr, id string, flag consensus.ServiceFlag) {
peer := NewP2PPeer(addr, id, flag)
nw.nodes[node] = *peer
}
-func (nw *NetWork) HandsShake(nodeA, nodeB *ChainManager) (*P2PPeer, *P2PPeer, error) {
+func (nw *NetWork) HandsShake(nodeA, nodeB *Manager) (*P2PPeer, *P2PPeer, error) {
B2A, ok := nw.nodes[nodeA]
if !ok {
return nil, nil, errors.New("can't find nodeA's p2p peer on network")
nodeA.AddPeer(&A2B)
nodeB.AddPeer(&B2A)
-
+ nodeA.SendStatus(B2A.srcPeer)
+ nodeB.SendStatus(A2B.srcPeer)
A2B.setAsync(true)
B2A.setAsync(true)
return &B2A, &A2B, nil
return blocks
}
-func mockSync(blocks []*types.Block) *ChainManager {
- chain := mock.NewChain()
+func mockErrorBlocks(startBlock *types.Block, height uint64, errBlockHeight uint64) []*types.Block {
+ blocks := []*types.Block{}
+ indexBlock := &types.Block{}
+ if startBlock == nil {
+ indexBlock = &types.Block{BlockHeader: types.BlockHeader{Version: uint64(rand.Uint32())}}
+ blocks = append(blocks, indexBlock)
+ } else {
+ indexBlock = startBlock
+ }
+
+ for indexBlock.Height < height {
+ block := &types.Block{
+ BlockHeader: types.BlockHeader{
+ Height: indexBlock.Height + 1,
+ PreviousBlockHash: indexBlock.Hash(),
+ Version: uint64(rand.Uint32()),
+ },
+ }
+ if block.Height == errBlockHeight {
+ block.TransactionsMerkleRoot = bc.NewHash([32]byte{0x1})
+ }
+ blocks = append(blocks, block)
+ indexBlock = block
+ }
+ return blocks
+}
+
+func mockSync(blocks []*types.Block, mempool *mock.Mempool, fastSyncDB dbm.DB) *Manager {
+ chain := mock.NewChain(mempool)
peers := peers.NewPeerSet(NewPeerSet())
chain.SetBestBlockHeader(&blocks[len(blocks)-1].BlockHeader)
for _, block := range blocks {
chain.SetBlockByHeight(block.Height, block)
}
- return &ChainManager{
+ return &Manager{
chain: chain,
- blockKeeper: newBlockKeeper(chain, peers),
+ blockKeeper: newBlockKeeper(chain, peers, fastSyncDB),
peers: peers,
+ mempool: mempool,
+ txSyncCh: make(chan *txSyncMsg),
}
}