p2p/pex_reactor_test.go

   1 package p2p
   2
   3 import (
   4         "io/ioutil"
   5         "math/rand"
   6         "os"
   7         "testing"
   8         "time"
   9
  10         "github.com/stretchr/testify/assert"
  11         "github.com/stretchr/testify/require"
  12         wire "github.com/tendermint/go-wire"
  13         cmn "github.com/tendermint/tmlibs/common"
  14         "github.com/tendermint/tmlibs/log"
  15 )
  16
  17 func TestPEXReactorBasic(t *testing.T) {
  18         assert, require := assert.New(t), require.New(t)
  19
  20         dir, err := ioutil.TempDir("", "pex_reactor")
  21         require.Nil(err)
  22         defer os.RemoveAll(dir)
  23         book := NewAddrBook(dir+"addrbook.json", true)
  24         book.SetLogger(log.TestingLogger())
  25
  26         r := NewPEXReactor(book)
  27         r.SetLogger(log.TestingLogger())
  28
  29         assert.NotNil(r)
  30         assert.NotEmpty(r.GetChannels())
  31 }
  32
  33 func TestPEXReactorAddRemovePeer(t *testing.T) {
  34         assert, require := assert.New(t), require.New(t)
  35
  36         dir, err := ioutil.TempDir("", "pex_reactor")
  37         require.Nil(err)
  38         defer os.RemoveAll(dir)
  39         book := NewAddrBook(dir+"addrbook.json", true)
  40         book.SetLogger(log.TestingLogger())
  41
  42         r := NewPEXReactor(book)
  43         r.SetLogger(log.TestingLogger())
  44
  45         size := book.Size()
  46         peer := createRandomPeer(false)
  47
  48         r.AddPeer(peer)
  49         assert.Equal(size+1, book.Size())
  50
  51         r.RemovePeer(peer, "peer not available")
  52         assert.Equal(size+1, book.Size())
  53
  54         outboundPeer := createRandomPeer(true)
  55
  56         r.AddPeer(outboundPeer)
  57         assert.Equal(size+1, book.Size(), "outbound peers should not be added to the address book")
  58
  59         r.RemovePeer(outboundPeer, "peer not available")
  60         assert.Equal(size+1, book.Size())
  61 }
  62
  63 func TestPEXReactorRunning(t *testing.T) {
  64         require := require.New(t)
  65
  66         N := 3
  67         switches := make([]*Switch, N)
  68
  69         dir, err := ioutil.TempDir("", "pex_reactor")
  70         require.Nil(err)
  71         defer os.RemoveAll(dir)
  72         book := NewAddrBook(dir+"addrbook.json", false)
  73         book.SetLogger(log.TestingLogger())
  74
  75         // create switches
  76         for i := 0; i < N; i++ {
  77                 switches[i] = makeSwitch(config, i, "127.0.0.1", "123.123.123", func(i int, sw *Switch) *Switch {
  78                         sw.SetLogger(log.TestingLogger().With("switch", i))
  79
  80                         r := NewPEXReactor(book)
  81                         r.SetLogger(log.TestingLogger())
  82                         r.SetEnsurePeersPeriod(250 * time.Millisecond)
  83                         sw.AddReactor("pex", r)
  84                         return sw
  85                 })
  86         }
  87
  88         // fill the address book and add listeners
  89         for _, s := range switches {
  90                 addr, _ := NewNetAddressString(s.NodeInfo().ListenAddr)
  91                 book.AddAddress(addr, addr)
  92                 s.AddListener(NewDefaultListener("tcp", s.NodeInfo().ListenAddr, true, log.TestingLogger()))
  93         }
  94
  95         // start switches
  96         for _, s := range switches {
  97                 _, err := s.Start() // start switch and reactors
  98                 require.Nil(err)
  99         }
 100
 101         time.Sleep(1 * time.Second)
 102
 103         // check peers are connected after some time
 104         for _, s := range switches {
 105                 outbound, inbound, _ := s.NumPeers()
 106                 if outbound+inbound == 0 {
 107                         t.Errorf("%v expected to be connected to at least one peer", s.NodeInfo().ListenAddr)
 108                 }
 109         }
 110
 111         // stop them
 112         for _, s := range switches {
 113                 s.Stop()
 114         }
 115 }
 116
 117 func TestPEXReactorReceive(t *testing.T) {
 118         assert, require := assert.New(t), require.New(t)
 119
 120         dir, err := ioutil.TempDir("", "pex_reactor")
 121         require.Nil(err)
 122         defer os.RemoveAll(dir)
 123         book := NewAddrBook(dir+"addrbook.json", true)
 124         book.SetLogger(log.TestingLogger())
 125
 126         r := NewPEXReactor(book)
 127         r.SetLogger(log.TestingLogger())
 128
 129         peer := createRandomPeer(false)
 130
 131         size := book.Size()
 132         netAddr, _ := NewNetAddressString(peer.ListenAddr)
 133         addrs := []*NetAddress{netAddr}
 134         msg := wire.BinaryBytes(struct{ PexMessage }{&pexAddrsMessage{Addrs: addrs}})
 135         r.Receive(PexChannel, peer, msg)
 136         assert.Equal(size+1, book.Size())
 137
 138         msg = wire.BinaryBytes(struct{ PexMessage }{&pexRequestMessage{}})
 139         r.Receive(PexChannel, peer, msg)
 140 }
 141
 142 func TestPEXReactorAbuseFromPeer(t *testing.T) {
 143         assert, require := assert.New(t), require.New(t)
 144
 145         dir, err := ioutil.TempDir("", "pex_reactor")
 146         require.Nil(err)
 147         defer os.RemoveAll(dir)
 148         book := NewAddrBook(dir+"addrbook.json", true)
 149         book.SetLogger(log.TestingLogger())
 150
 151         r := NewPEXReactor(book)
 152         r.SetLogger(log.TestingLogger())
 153         r.SetMaxMsgCountByPeer(5)
 154
 155         peer := createRandomPeer(false)
 156
 157         msg := wire.BinaryBytes(struct{ PexMessage }{&pexRequestMessage{}})
 158         for i := 0; i < 10; i++ {
 159                 r.Receive(PexChannel, peer, msg)
 160         }
 161
 162         assert.True(r.ReachedMaxMsgCountForPeer(peer.ListenAddr))
 163 }
 164
 165 func createRandomPeer(outbound bool) *Peer {
 166         addr := cmn.Fmt("%v.%v.%v.%v:46656", rand.Int()%256, rand.Int()%256, rand.Int()%256, rand.Int()%256)
 167         netAddr, _ := NewNetAddressString(addr)
 168         p := &Peer{
 169                 Key: cmn.RandStr(12),
 170                 NodeInfo: &NodeInfo{
 171                         ListenAddr: addr,
 172                 },
 173                 outbound: outbound,
 174                 mconn:    &MConnection{RemoteAddress: netAddr},
 175         }
 176         p.SetLogger(log.TestingLogger().With("peer", addr))
 177         return p
 178 }