p2p/peer_test.go

   1 package p2p
   2
   3 import (
   4         "fmt"
   5         "net"
   6         "testing"
   7         "time"
   8
   9         cfg "github.com/vapor/config"
  10         conn "github.com/vapor/p2p/connection"
  11         "github.com/vapor/p2p/signlib"
  12         "github.com/vapor/version"
  13 )
  14
  15 const testCh = 0x01
  16
  17 func TestPeerBasic(t *testing.T) {
  18         privKey, err := signlib.NewPrivKey()
  19         if err != nil {
  20                 t.Fatal(err)
  21         }
  22
  23         // simulate remote peer
  24         rp := &remotePeer{PrivKey: privKey, Config: testCfg}
  25         rp.Start()
  26         defer rp.Stop()
  27
  28         p, err := createOutboundPeerAndPerformHandshake(rp.Addr(), cfg.DefaultP2PConfig())
  29         if err != nil {
  30                 t.Fatal(err)
  31         }
  32         _, err = p.Start()
  33         if err != nil {
  34                 t.Fatal(err)
  35         }
  36         defer p.Stop()
  37 }
  38
  39 func TestPeerSend(t *testing.T) {
  40         config := testCfg
  41         privKey, err := signlib.NewPrivKey()
  42         if err != nil {
  43                 t.Fatal(err)
  44         }
  45         // simulate remote peer
  46         rp := &remotePeer{PrivKey: privKey, Config: config}
  47         rp.Start()
  48         defer rp.Stop()
  49
  50         p, err := createOutboundPeerAndPerformHandshake(rp.Addr(), config.P2P)
  51         if err != nil {
  52                 t.Fatal(err)
  53         }
  54
  55         _, err = p.Start()
  56         if err != nil {
  57                 t.Fatal(err)
  58         }
  59
  60         defer p.Stop()
  61         if ok := p.CanSend(testCh); !ok {
  62                 t.Fatal("TestPeerSend send err")
  63         }
  64
  65         if ok := p.TrySend(testCh, []byte("test date")); !ok {
  66                 t.Fatal("TestPeerSend try send err")
  67         }
  68 }
  69
  70 func createOutboundPeerAndPerformHandshake(
  71         addr *NetAddress,
  72         config *cfg.P2PConfig,
  73 ) (*Peer, error) {
  74         chDescs := []*conn.ChannelDescriptor{
  75                 {ID: testCh, Priority: 1},
  76         }
  77         reactorsByCh := map[byte]Reactor{testCh: NewTestReactor(chDescs, true)}
  78         privKey, err := signlib.NewPrivKey()
  79         if err != nil {
  80                 return nil, err
  81         }
  82         peerConfig := DefaultPeerConfig(config)
  83         pc, err := newOutboundPeerConn(addr, privKey, peerConfig)
  84         if err != nil {
  85                 return nil, err
  86         }
  87         nodeInfo, err := pc.HandshakeTimeout(&NodeInfo{
  88                 Moniker: "host_peer",
  89                 Network: "testing",
  90                 Version: "123.123.123",
  91         }, 5*time.Second)
  92         if err != nil {
  93                 fmt.Println(err)
  94                 return nil, err
  95         }
  96         p := newPeer(pc, nodeInfo, reactorsByCh, chDescs, nil, false)
  97         return p, nil
  98 }
  99
 100 type remotePeer struct {
 101         PrivKey    signlib.PrivKey
 102         Config     *cfg.Config
 103         addr       *NetAddress
 104         quit       chan struct{}
 105         listenAddr string
 106 }
 107
 108 func (rp *remotePeer) Addr() *NetAddress {
 109         return rp.addr
 110 }
 111
 112 func (rp *remotePeer) Start() {
 113         if rp.listenAddr == "" {
 114                 rp.listenAddr = "127.0.0.1:0"
 115         }
 116
 117         l, e := net.Listen("tcp", rp.listenAddr) // any available address
 118         if e != nil {
 119                 fmt.Println("net.Listen tcp :0:", e)
 120         }
 121         rp.addr = NewNetAddress(l.Addr())
 122         rp.quit = make(chan struct{})
 123         go rp.accept(l)
 124 }
 125
 126 func (rp *remotePeer) Stop() {
 127         close(rp.quit)
 128 }
 129
 130 func (rp *remotePeer) accept(l net.Listener) {
 131         conns := []net.Conn{}
 132
 133         for {
 134                 conn, err := l.Accept()
 135                 if err != nil {
 136                         fmt.Println("Failed to accept conn:", err)
 137                 }
 138
 139                 pc, err := newInboundPeerConn(conn, rp.PrivKey, rp.Config.P2P)
 140                 if err != nil {
 141                         fmt.Println("Failed to create a peer:", err)
 142                 }
 143
 144                 _, err = pc.HandshakeTimeout(&NodeInfo{
 145                         PubKey:     rp.PrivKey.XPub().String(),
 146                         Moniker:    "remote_peer",
 147                         Network:    rp.Config.ChainID,
 148                         Version:    version.Version,
 149                         ListenAddr: l.Addr().String(),
 150                 }, 5*time.Second)
 151                 if err != nil {
 152                         fmt.Println("Failed to perform handshake:", err)
 153                 }
 154                 conns = append(conns, conn)
 155                 select {
 156                 case <-rp.quit:
 157                         for _, conn := range conns {
 158                                 if err := conn.Close(); err != nil {
 159                                         fmt.Println(err)
 160                                 }
 161                         }
 162                         return
 163                 default:
 164                 }
 165         }
 166 }
 167
 168 type inboundPeer struct {
 169         PrivKey signlib.PrivKey
 170         config  *cfg.Config
 171 }
 172
 173 func (ip *inboundPeer) dial(addr *NetAddress) {
 174         pc, err := newOutboundPeerConn(addr, ip.PrivKey, DefaultPeerConfig(ip.config.P2P))
 175         if err != nil {
 176                 fmt.Println("newOutboundPeerConn:", err)
 177                 return
 178         }
 179
 180         _, err = pc.HandshakeTimeout(&NodeInfo{
 181                 PubKey:     ip.PrivKey.XPub().String(),
 182                 Moniker:    "remote_peer",
 183                 Network:    ip.config.ChainID,
 184                 Version:    version.Version,
 185                 ListenAddr: addr.String(),
 186         }, 5*time.Second)
 187         if err != nil {
 188                 fmt.Println("Failed to perform handshake:", err)
 189                 return
 190         }
 191         time.AfterFunc(10*time.Second, pc.CloseConn)
 192 }