p2p/pex_reactor_test.go

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