netsync/tool_test.go

   1 package netsync
   2
   3 import (
   4         "errors"
   5         "math/rand"
   6         "net"
   7
   8         wire "github.com/tendermint/go-wire"
   9         "github.com/tendermint/tmlibs/flowrate"
  10
  11         "github.com/vapor/consensus"
  12         "github.com/vapor/protocol/bc"
  13         "github.com/vapor/protocol/bc/types"
  14         "github.com/vapor/test/mock"
  15 )
  16
  17 type P2PPeer struct {
  18         id   string
  19         ip   *net.IPAddr
  20         flag consensus.ServiceFlag
  21
  22         srcPeer    *P2PPeer
  23         remoteNode *SyncManager
  24         msgCh      chan []byte
  25         async      bool
  26 }
  27
  28 func NewP2PPeer(addr, id string, flag consensus.ServiceFlag) *P2PPeer {
  29         return &P2PPeer{
  30                 id:    id,
  31                 ip:    &net.IPAddr{IP: net.ParseIP(addr)},
  32                 flag:  flag,
  33                 msgCh: make(chan []byte),
  34                 async: false,
  35         }
  36 }
  37
  38 func (p *P2PPeer) Addr() net.Addr {
  39         return p.ip
  40 }
  41
  42 func (p *P2PPeer) ID() string {
  43         return p.id
  44 }
  45
  46 func (p *P2PPeer) IsLAN() bool {
  47         return false
  48 }
  49
  50 func (p *P2PPeer) ServiceFlag() consensus.ServiceFlag {
  51         return p.flag
  52 }
  53
  54 func (p *P2PPeer) SetConnection(srcPeer *P2PPeer, node *SyncManager) {
  55         p.srcPeer = srcPeer
  56         p.remoteNode = node
  57 }
  58
  59 func (p *P2PPeer) TrafficStatus() (*flowrate.Status, *flowrate.Status) {
  60         return nil, nil
  61 }
  62
  63 func (p *P2PPeer) TrySend(b byte, msg interface{}) bool {
  64         msgBytes := wire.BinaryBytes(msg)
  65         if p.async {
  66                 p.msgCh <- msgBytes
  67         } else {
  68                 msgType, msg, _ := DecodeMessage(msgBytes)
  69                 p.remoteNode.processMsg(p.srcPeer, msgType, msg)
  70         }
  71         return true
  72 }
  73
  74 func (p *P2PPeer) setAsync(b bool) {
  75         p.async = b
  76 }
  77
  78 func (p *P2PPeer) postMan() {
  79         for msgBytes := range p.msgCh {
  80                 msgType, msg, _ := DecodeMessage(msgBytes)
  81                 p.remoteNode.processMsg(p.srcPeer, msgType, msg)
  82         }
  83 }
  84
  85 type PeerSet struct{}
  86
  87 func NewPeerSet() *PeerSet {
  88         return &PeerSet{}
  89 }
  90
  91 func (ps *PeerSet) AddBannedPeer(string) error { return nil }
  92 func (ps *PeerSet) StopPeerGracefully(string)  {}
  93
  94 type NetWork struct {
  95         nodes map[*SyncManager]P2PPeer
  96 }
  97
  98 func NewNetWork() *NetWork {
  99         return &NetWork{map[*SyncManager]P2PPeer{}}
 100 }
 101
 102 func (nw *NetWork) Register(node *SyncManager, addr, id string, flag consensus.ServiceFlag) {
 103         peer := NewP2PPeer(addr, id, flag)
 104         nw.nodes[node] = *peer
 105 }
 106
 107 func (nw *NetWork) HandsShake(nodeA, nodeB *SyncManager) (*P2PPeer, *P2PPeer, error) {
 108         B2A, ok := nw.nodes[nodeA]
 109         if !ok {
 110                 return nil, nil, errors.New("can't find nodeA's p2p peer on network")
 111         }
 112         A2B, ok := nw.nodes[nodeB]
 113         if !ok {
 114                 return nil, nil, errors.New("can't find nodeB's p2p peer on network")
 115         }
 116
 117         A2B.SetConnection(&B2A, nodeB)
 118         B2A.SetConnection(&A2B, nodeA)
 119
 120         nodeA.handleStatusRequestMsg(&A2B)
 121         nodeB.handleStatusRequestMsg(&B2A)
 122
 123         A2B.setAsync(true)
 124         B2A.setAsync(true)
 125         return &B2A, &A2B, nil
 126 }
 127
 128 func mockBlocks(startBlock *types.Block, height uint64) []*types.Block {
 129         blocks := []*types.Block{}
 130         indexBlock := &types.Block{}
 131         if startBlock == nil {
 132                 indexBlock = &types.Block{BlockHeader: types.BlockHeader{Version: uint64(rand.Uint32())}}
 133                 blocks = append(blocks, indexBlock)
 134         } else {
 135                 indexBlock = startBlock
 136         }
 137
 138         for indexBlock.Height < height {
 139                 block := &types.Block{
 140                         BlockHeader: types.BlockHeader{
 141                                 Height:            indexBlock.Height + 1,
 142                                 PreviousBlockHash: indexBlock.Hash(),
 143                                 Version:           uint64(rand.Uint32()),
 144                         },
 145                 }
 146                 blocks = append(blocks, block)
 147                 indexBlock = block
 148         }
 149         return blocks
 150 }
 151
 152 func mockSync(blocks []*types.Block) *SyncManager {
 153         chain := mock.NewChain()
 154         peers := newPeerSet(NewPeerSet())
 155         chain.SetBestBlockHeader(&blocks[len(blocks)-1].BlockHeader)
 156         for _, block := range blocks {
 157                 chain.SetBlockByHeight(block.Height, block)
 158         }
 159
 160         genesis, _ := chain.GetHeaderByHeight(0)
 161         return &SyncManager{
 162                 genesisHash: genesis.Hash(),
 163                 chain:       chain,
 164                 blockKeeper: newBlockKeeper(chain, peers),
 165                 peers:       peers,
 166         }
 167 }
 168
 169 func mockTxs(txCount int) ([]*types.Tx, []*bc.Tx) {
 170         var txs []*types.Tx
 171         var bcTxs []*bc.Tx
 172         trueProg := mockControlProgram(60)
 173         assetID := bc.AssetID{V0: 9999}
 174         for i := uint64(0); i < uint64(txCount); i++ {
 175                 tx := types.NewTx(types.TxData{
 176                         Version: 1,
 177                         Inputs:  []*types.TxInput{types.NewSpendInput(nil, bc.Hash{V0: i + 1}, assetID, i, i, trueProg)},
 178                         Outputs: []*types.TxOutput{types.NewIntraChainOutput(assetID, 1, trueProg)},
 179                 })
 180                 txs = append(txs, tx)
 181                 bcTxs = append(bcTxs, tx.Tx)
 182         }
 183         return txs, bcTxs
 184 }
 185
 186 func mockControlProgram(length int) []byte {
 187         var cp []byte
 188         for i := 0; i < length; i++ {
 189                 cp = append(cp, byte(rand.Intn(1<<8)))
 190         }
 191         return cp
 192 }