You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
829 lines
20 KiB
829 lines
20 KiB
package p2p
|
|
|
|
import (
|
|
"bytes"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"io/ioutil"
|
|
"net"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"regexp"
|
|
"strconv"
|
|
"sync/atomic"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/prometheus/client_golang/prometheus/promhttp"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"github.com/tendermint/tendermint/config"
|
|
"github.com/tendermint/tendermint/crypto/ed25519"
|
|
"github.com/tendermint/tendermint/libs/log"
|
|
tmsync "github.com/tendermint/tendermint/libs/sync"
|
|
"github.com/tendermint/tendermint/p2p/conn"
|
|
)
|
|
|
|
var (
|
|
cfg *config.P2PConfig
|
|
)
|
|
|
|
func init() {
|
|
cfg = config.DefaultP2PConfig()
|
|
cfg.PexReactor = true
|
|
cfg.AllowDuplicateIP = true
|
|
}
|
|
|
|
type PeerMessage struct {
|
|
PeerID ID
|
|
Bytes []byte
|
|
Counter int
|
|
}
|
|
|
|
type TestReactor struct {
|
|
BaseReactor
|
|
|
|
mtx tmsync.Mutex
|
|
channels []*conn.ChannelDescriptor
|
|
logMessages bool
|
|
msgsCounter int
|
|
msgsReceived map[byte][]PeerMessage
|
|
}
|
|
|
|
func NewTestReactor(channels []*conn.ChannelDescriptor, logMessages bool) *TestReactor {
|
|
tr := &TestReactor{
|
|
channels: channels,
|
|
logMessages: logMessages,
|
|
msgsReceived: make(map[byte][]PeerMessage),
|
|
}
|
|
tr.BaseReactor = *NewBaseReactor("TestReactor", tr)
|
|
tr.SetLogger(log.TestingLogger())
|
|
return tr
|
|
}
|
|
|
|
func (tr *TestReactor) GetChannels() []*conn.ChannelDescriptor {
|
|
return tr.channels
|
|
}
|
|
|
|
func (tr *TestReactor) AddPeer(peer Peer) {}
|
|
|
|
func (tr *TestReactor) RemovePeer(peer Peer, reason interface{}) {}
|
|
|
|
func (tr *TestReactor) Receive(chID byte, peer Peer, msgBytes []byte) {
|
|
if tr.logMessages {
|
|
tr.mtx.Lock()
|
|
defer tr.mtx.Unlock()
|
|
//fmt.Printf("Received: %X, %X\n", chID, msgBytes)
|
|
tr.msgsReceived[chID] = append(tr.msgsReceived[chID], PeerMessage{peer.ID(), msgBytes, tr.msgsCounter})
|
|
tr.msgsCounter++
|
|
}
|
|
}
|
|
|
|
func (tr *TestReactor) getMsgs(chID byte) []PeerMessage {
|
|
tr.mtx.Lock()
|
|
defer tr.mtx.Unlock()
|
|
return tr.msgsReceived[chID]
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// convenience method for creating two switches connected to each other.
|
|
// XXX: note this uses net.Pipe and not a proper TCP conn
|
|
func MakeSwitchPair(t testing.TB, initSwitch func(int, *Switch) *Switch) (*Switch, *Switch) {
|
|
// Create two switches that will be interconnected.
|
|
switches := MakeConnectedSwitches(cfg, 2, initSwitch, Connect2Switches)
|
|
return switches[0], switches[1]
|
|
}
|
|
|
|
func initSwitchFunc(i int, sw *Switch) *Switch {
|
|
sw.SetAddrBook(&AddrBookMock{
|
|
Addrs: make(map[string]struct{}),
|
|
OurAddrs: make(map[string]struct{})})
|
|
|
|
// Make two reactors of two channels each
|
|
sw.AddReactor("foo", NewTestReactor([]*conn.ChannelDescriptor{
|
|
{ID: byte(0x00), Priority: 10},
|
|
{ID: byte(0x01), Priority: 10},
|
|
}, true))
|
|
sw.AddReactor("bar", NewTestReactor([]*conn.ChannelDescriptor{
|
|
{ID: byte(0x02), Priority: 10},
|
|
{ID: byte(0x03), Priority: 10},
|
|
}, true))
|
|
|
|
return sw
|
|
}
|
|
|
|
func TestSwitches(t *testing.T) {
|
|
s1, s2 := MakeSwitchPair(t, initSwitchFunc)
|
|
t.Cleanup(func() {
|
|
if err := s1.Stop(); err != nil {
|
|
t.Error(err)
|
|
}
|
|
})
|
|
t.Cleanup(func() {
|
|
if err := s2.Stop(); err != nil {
|
|
t.Error(err)
|
|
}
|
|
})
|
|
|
|
if s1.Peers().Size() != 1 {
|
|
t.Errorf("expected exactly 1 peer in s1, got %v", s1.Peers().Size())
|
|
}
|
|
if s2.Peers().Size() != 1 {
|
|
t.Errorf("expected exactly 1 peer in s2, got %v", s2.Peers().Size())
|
|
}
|
|
|
|
// Lets send some messages
|
|
ch0Msg := []byte("channel zero")
|
|
ch1Msg := []byte("channel foo")
|
|
ch2Msg := []byte("channel bar")
|
|
|
|
s1.Broadcast(byte(0x00), ch0Msg)
|
|
s1.Broadcast(byte(0x01), ch1Msg)
|
|
s1.Broadcast(byte(0x02), ch2Msg)
|
|
|
|
assertMsgReceivedWithTimeout(t,
|
|
ch0Msg,
|
|
byte(0x00),
|
|
s2.Reactor("foo").(*TestReactor), 10*time.Millisecond, 5*time.Second)
|
|
assertMsgReceivedWithTimeout(t,
|
|
ch1Msg,
|
|
byte(0x01),
|
|
s2.Reactor("foo").(*TestReactor), 10*time.Millisecond, 5*time.Second)
|
|
assertMsgReceivedWithTimeout(t,
|
|
ch2Msg,
|
|
byte(0x02),
|
|
s2.Reactor("bar").(*TestReactor), 10*time.Millisecond, 5*time.Second)
|
|
}
|
|
|
|
func assertMsgReceivedWithTimeout(
|
|
t *testing.T,
|
|
msgBytes []byte,
|
|
channel byte,
|
|
reactor *TestReactor,
|
|
checkPeriod,
|
|
timeout time.Duration,
|
|
) {
|
|
ticker := time.NewTicker(checkPeriod)
|
|
for {
|
|
select {
|
|
case <-ticker.C:
|
|
msgs := reactor.getMsgs(channel)
|
|
if len(msgs) > 0 {
|
|
if !bytes.Equal(msgs[0].Bytes, msgBytes) {
|
|
t.Fatalf("Unexpected message bytes. Wanted: %X, Got: %X", msgBytes, msgs[0].Bytes)
|
|
}
|
|
return
|
|
}
|
|
|
|
case <-time.After(timeout):
|
|
t.Fatalf("Expected to have received 1 message in channel #%v, got zero", channel)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestSwitchFiltersOutItself(t *testing.T) {
|
|
s1 := MakeSwitch(cfg, 1, "127.0.0.1", "123.123.123", initSwitchFunc)
|
|
|
|
// simulate s1 having a public IP by creating a remote peer with the same ID
|
|
rp := &remotePeer{PrivKey: s1.nodeKey.PrivKey, Config: cfg}
|
|
rp.Start()
|
|
|
|
// addr should be rejected in addPeer based on the same ID
|
|
err := s1.DialPeerWithAddress(rp.Addr())
|
|
if assert.Error(t, err) {
|
|
if err, ok := err.(ErrRejected); ok {
|
|
if !err.IsSelf() {
|
|
t.Errorf("expected self to be rejected")
|
|
}
|
|
} else {
|
|
t.Errorf("expected ErrRejected")
|
|
}
|
|
}
|
|
|
|
assert.True(t, s1.addrBook.OurAddress(rp.Addr()))
|
|
assert.False(t, s1.addrBook.HasAddress(rp.Addr()))
|
|
|
|
rp.Stop()
|
|
|
|
assertNoPeersAfterTimeout(t, s1, 100*time.Millisecond)
|
|
}
|
|
|
|
func TestSwitchPeerFilter(t *testing.T) {
|
|
var (
|
|
filters = []PeerFilterFunc{
|
|
func(_ IPeerSet, _ Peer) error { return nil },
|
|
func(_ IPeerSet, _ Peer) error { return fmt.Errorf("denied") },
|
|
func(_ IPeerSet, _ Peer) error { return nil },
|
|
}
|
|
sw = MakeSwitch(
|
|
cfg,
|
|
1,
|
|
"testing",
|
|
"123.123.123",
|
|
initSwitchFunc,
|
|
SwitchPeerFilters(filters...),
|
|
)
|
|
)
|
|
sw.Start()
|
|
t.Cleanup(func() {
|
|
if err := sw.Stop(); err != nil {
|
|
t.Error(err)
|
|
}
|
|
})
|
|
|
|
// simulate remote peer
|
|
rp := &remotePeer{PrivKey: ed25519.GenPrivKey(), Config: cfg}
|
|
rp.Start()
|
|
t.Cleanup(rp.Stop)
|
|
|
|
p, err := sw.transport.Dial(*rp.Addr(), peerConfig{
|
|
chDescs: sw.chDescs,
|
|
onPeerError: sw.StopPeerForError,
|
|
isPersistent: sw.IsPeerPersistent,
|
|
reactorsByCh: sw.reactorsByCh,
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
err = sw.addPeer(p)
|
|
if err, ok := err.(ErrRejected); ok {
|
|
if !err.IsFiltered() {
|
|
t.Errorf("expected peer to be filtered")
|
|
}
|
|
} else {
|
|
t.Errorf("expected ErrRejected")
|
|
}
|
|
}
|
|
|
|
func TestSwitchPeerFilterTimeout(t *testing.T) {
|
|
var (
|
|
filters = []PeerFilterFunc{
|
|
func(_ IPeerSet, _ Peer) error {
|
|
time.Sleep(10 * time.Millisecond)
|
|
return nil
|
|
},
|
|
}
|
|
sw = MakeSwitch(
|
|
cfg,
|
|
1,
|
|
"testing",
|
|
"123.123.123",
|
|
initSwitchFunc,
|
|
SwitchFilterTimeout(5*time.Millisecond),
|
|
SwitchPeerFilters(filters...),
|
|
)
|
|
)
|
|
sw.Start()
|
|
t.Cleanup(func() {
|
|
if err := sw.Stop(); err != nil {
|
|
t.Log(err)
|
|
}
|
|
})
|
|
|
|
// simulate remote peer
|
|
rp := &remotePeer{PrivKey: ed25519.GenPrivKey(), Config: cfg}
|
|
rp.Start()
|
|
defer rp.Stop()
|
|
|
|
p, err := sw.transport.Dial(*rp.Addr(), peerConfig{
|
|
chDescs: sw.chDescs,
|
|
onPeerError: sw.StopPeerForError,
|
|
isPersistent: sw.IsPeerPersistent,
|
|
reactorsByCh: sw.reactorsByCh,
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
err = sw.addPeer(p)
|
|
if _, ok := err.(ErrFilterTimeout); !ok {
|
|
t.Errorf("expected ErrFilterTimeout")
|
|
}
|
|
}
|
|
|
|
func TestSwitchPeerFilterDuplicate(t *testing.T) {
|
|
sw := MakeSwitch(cfg, 1, "testing", "123.123.123", initSwitchFunc)
|
|
err := sw.Start()
|
|
require.NoError(t, err)
|
|
t.Cleanup(func() {
|
|
if err := sw.Stop(); err != nil {
|
|
t.Error(err)
|
|
}
|
|
})
|
|
|
|
// simulate remote peer
|
|
rp := &remotePeer{PrivKey: ed25519.GenPrivKey(), Config: cfg}
|
|
rp.Start()
|
|
defer rp.Stop()
|
|
|
|
p, err := sw.transport.Dial(*rp.Addr(), peerConfig{
|
|
chDescs: sw.chDescs,
|
|
onPeerError: sw.StopPeerForError,
|
|
isPersistent: sw.IsPeerPersistent,
|
|
reactorsByCh: sw.reactorsByCh,
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if err := sw.addPeer(p); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
err = sw.addPeer(p)
|
|
if errRej, ok := err.(ErrRejected); ok {
|
|
if !errRej.IsDuplicate() {
|
|
t.Errorf("expected peer to be duplicate. got %v", errRej)
|
|
}
|
|
} else {
|
|
t.Errorf("expected ErrRejected, got %v", err)
|
|
}
|
|
}
|
|
|
|
func assertNoPeersAfterTimeout(t *testing.T, sw *Switch, timeout time.Duration) {
|
|
time.Sleep(timeout)
|
|
if sw.Peers().Size() != 0 {
|
|
t.Fatalf("Expected %v to not connect to some peers, got %d", sw, sw.Peers().Size())
|
|
}
|
|
}
|
|
|
|
func TestSwitchStopsNonPersistentPeerOnError(t *testing.T) {
|
|
assert, require := assert.New(t), require.New(t)
|
|
|
|
sw := MakeSwitch(cfg, 1, "testing", "123.123.123", initSwitchFunc)
|
|
err := sw.Start()
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
t.Cleanup(func() {
|
|
if err := sw.Stop(); err != nil {
|
|
t.Error(err)
|
|
}
|
|
})
|
|
|
|
// simulate remote peer
|
|
rp := &remotePeer{PrivKey: ed25519.GenPrivKey(), Config: cfg}
|
|
rp.Start()
|
|
defer rp.Stop()
|
|
|
|
p, err := sw.transport.Dial(*rp.Addr(), peerConfig{
|
|
chDescs: sw.chDescs,
|
|
onPeerError: sw.StopPeerForError,
|
|
isPersistent: sw.IsPeerPersistent,
|
|
reactorsByCh: sw.reactorsByCh,
|
|
})
|
|
require.Nil(err)
|
|
|
|
err = sw.addPeer(p)
|
|
require.Nil(err)
|
|
|
|
require.NotNil(sw.Peers().Get(rp.ID()))
|
|
|
|
// simulate failure by closing connection
|
|
p.(*peer).CloseConn()
|
|
|
|
assertNoPeersAfterTimeout(t, sw, 100*time.Millisecond)
|
|
assert.False(p.IsRunning())
|
|
}
|
|
|
|
func TestSwitchStopPeerForError(t *testing.T) {
|
|
s := httptest.NewServer(promhttp.Handler())
|
|
defer s.Close()
|
|
|
|
scrapeMetrics := func() string {
|
|
resp, err := http.Get(s.URL)
|
|
assert.NoError(t, err)
|
|
defer resp.Body.Close()
|
|
buf, _ := ioutil.ReadAll(resp.Body)
|
|
return string(buf)
|
|
}
|
|
|
|
namespace, subsystem, name := config.TestInstrumentationConfig().Namespace, MetricsSubsystem, "peers"
|
|
re := regexp.MustCompile(namespace + `_` + subsystem + `_` + name + ` ([0-9\.]+)`)
|
|
peersMetricValue := func() float64 {
|
|
matches := re.FindStringSubmatch(scrapeMetrics())
|
|
f, _ := strconv.ParseFloat(matches[1], 64)
|
|
return f
|
|
}
|
|
|
|
p2pMetrics := PrometheusMetrics(namespace)
|
|
|
|
// make two connected switches
|
|
sw1, sw2 := MakeSwitchPair(t, func(i int, sw *Switch) *Switch {
|
|
// set metrics on sw1
|
|
if i == 0 {
|
|
opt := WithMetrics(p2pMetrics)
|
|
opt(sw)
|
|
}
|
|
return initSwitchFunc(i, sw)
|
|
})
|
|
|
|
assert.Equal(t, len(sw1.Peers().List()), 1)
|
|
assert.EqualValues(t, 1, peersMetricValue())
|
|
|
|
// send messages to the peer from sw1
|
|
p := sw1.Peers().List()[0]
|
|
p.Send(0x1, []byte("here's a message to send"))
|
|
|
|
// stop sw2. this should cause the p to fail,
|
|
// which results in calling StopPeerForError internally
|
|
t.Cleanup(func() {
|
|
if err := sw2.Stop(); err != nil {
|
|
t.Error(err)
|
|
}
|
|
})
|
|
|
|
// now call StopPeerForError explicitly, eg. from a reactor
|
|
sw1.StopPeerForError(p, fmt.Errorf("some err"))
|
|
|
|
assert.Equal(t, len(sw1.Peers().List()), 0)
|
|
assert.EqualValues(t, 0, peersMetricValue())
|
|
}
|
|
|
|
func TestSwitchReconnectsToOutboundPersistentPeer(t *testing.T) {
|
|
sw := MakeSwitch(cfg, 1, "testing", "123.123.123", initSwitchFunc)
|
|
err := sw.Start()
|
|
require.NoError(t, err)
|
|
t.Cleanup(func() {
|
|
if err := sw.Stop(); err != nil {
|
|
t.Error(err)
|
|
}
|
|
})
|
|
|
|
// 1. simulate failure by closing connection
|
|
rp := &remotePeer{PrivKey: ed25519.GenPrivKey(), Config: cfg}
|
|
rp.Start()
|
|
defer rp.Stop()
|
|
|
|
err = sw.AddPersistentPeers([]string{rp.Addr().String()})
|
|
require.NoError(t, err)
|
|
|
|
err = sw.DialPeerWithAddress(rp.Addr())
|
|
require.Nil(t, err)
|
|
require.NotNil(t, sw.Peers().Get(rp.ID()))
|
|
|
|
p := sw.Peers().List()[0]
|
|
p.(*peer).CloseConn()
|
|
|
|
waitUntilSwitchHasAtLeastNPeers(sw, 1)
|
|
assert.False(t, p.IsRunning()) // old peer instance
|
|
assert.Equal(t, 1, sw.Peers().Size()) // new peer instance
|
|
|
|
// 2. simulate first time dial failure
|
|
rp = &remotePeer{
|
|
PrivKey: ed25519.GenPrivKey(),
|
|
Config: cfg,
|
|
// Use different interface to prevent duplicate IP filter, this will break
|
|
// beyond two peers.
|
|
listenAddr: "127.0.0.1:0",
|
|
}
|
|
rp.Start()
|
|
defer rp.Stop()
|
|
|
|
conf := config.DefaultP2PConfig()
|
|
conf.TestDialFail = true // will trigger a reconnect
|
|
err = sw.addOutboundPeerWithConfig(rp.Addr(), conf)
|
|
require.NotNil(t, err)
|
|
// DialPeerWithAddres - sw.peerConfig resets the dialer
|
|
waitUntilSwitchHasAtLeastNPeers(sw, 2)
|
|
assert.Equal(t, 2, sw.Peers().Size())
|
|
}
|
|
|
|
func TestSwitchReconnectsToInboundPersistentPeer(t *testing.T) {
|
|
sw := MakeSwitch(cfg, 1, "testing", "123.123.123", initSwitchFunc)
|
|
err := sw.Start()
|
|
require.NoError(t, err)
|
|
t.Cleanup(func() {
|
|
if err := sw.Stop(); err != nil {
|
|
t.Error(err)
|
|
}
|
|
})
|
|
|
|
// 1. simulate failure by closing the connection
|
|
rp := &remotePeer{PrivKey: ed25519.GenPrivKey(), Config: cfg}
|
|
rp.Start()
|
|
defer rp.Stop()
|
|
|
|
err = sw.AddPersistentPeers([]string{rp.Addr().String()})
|
|
require.NoError(t, err)
|
|
|
|
conn, err := rp.Dial(sw.NetAddress())
|
|
require.NoError(t, err)
|
|
time.Sleep(50 * time.Millisecond)
|
|
require.NotNil(t, sw.Peers().Get(rp.ID()))
|
|
|
|
conn.Close()
|
|
|
|
waitUntilSwitchHasAtLeastNPeers(sw, 1)
|
|
assert.Equal(t, 1, sw.Peers().Size())
|
|
}
|
|
|
|
func TestSwitchDialPeersAsync(t *testing.T) {
|
|
if testing.Short() {
|
|
return
|
|
}
|
|
|
|
sw := MakeSwitch(cfg, 1, "testing", "123.123.123", initSwitchFunc)
|
|
err := sw.Start()
|
|
require.NoError(t, err)
|
|
t.Cleanup(func() {
|
|
if err := sw.Stop(); err != nil {
|
|
t.Error(err)
|
|
}
|
|
})
|
|
|
|
rp := &remotePeer{PrivKey: ed25519.GenPrivKey(), Config: cfg}
|
|
rp.Start()
|
|
defer rp.Stop()
|
|
|
|
err = sw.DialPeersAsync([]string{rp.Addr().String()})
|
|
require.NoError(t, err)
|
|
time.Sleep(dialRandomizerIntervalMilliseconds * time.Millisecond)
|
|
require.NotNil(t, sw.Peers().Get(rp.ID()))
|
|
}
|
|
|
|
func waitUntilSwitchHasAtLeastNPeers(sw *Switch, n int) {
|
|
for i := 0; i < 20; i++ {
|
|
time.Sleep(250 * time.Millisecond)
|
|
has := sw.Peers().Size()
|
|
if has >= n {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestSwitchFullConnectivity(t *testing.T) {
|
|
switches := MakeConnectedSwitches(cfg, 3, initSwitchFunc, Connect2Switches)
|
|
defer func() {
|
|
for _, sw := range switches {
|
|
sw := sw
|
|
t.Cleanup(func() {
|
|
if err := sw.Stop(); err != nil {
|
|
t.Error(err)
|
|
}
|
|
})
|
|
}
|
|
}()
|
|
|
|
for i, sw := range switches {
|
|
if sw.Peers().Size() != 2 {
|
|
t.Fatalf("Expected each switch to be connected to 2 other, but %d switch only connected to %d", sw.Peers().Size(), i)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestSwitchAcceptRoutine(t *testing.T) {
|
|
cfg.MaxNumInboundPeers = 5
|
|
|
|
// Create some unconditional peers.
|
|
const unconditionalPeersNum = 2
|
|
var (
|
|
unconditionalPeers = make([]*remotePeer, unconditionalPeersNum)
|
|
unconditionalPeerIDs = make([]string, unconditionalPeersNum)
|
|
)
|
|
for i := 0; i < unconditionalPeersNum; i++ {
|
|
peer := &remotePeer{PrivKey: ed25519.GenPrivKey(), Config: cfg}
|
|
peer.Start()
|
|
unconditionalPeers[i] = peer
|
|
unconditionalPeerIDs[i] = string(peer.ID())
|
|
}
|
|
|
|
// make switch
|
|
sw := MakeSwitch(cfg, 1, "testing", "123.123.123", initSwitchFunc)
|
|
sw.AddUnconditionalPeerIDs(unconditionalPeerIDs)
|
|
err := sw.Start()
|
|
require.NoError(t, err)
|
|
t.Cleanup(func() {
|
|
if err := sw.Stop(); err != nil {
|
|
t.Error(err)
|
|
}
|
|
})
|
|
|
|
// 0. check there are no peers
|
|
assert.Equal(t, 0, sw.Peers().Size())
|
|
|
|
// 1. check we connect up to MaxNumInboundPeers
|
|
peers := make([]*remotePeer, 0)
|
|
for i := 0; i < cfg.MaxNumInboundPeers; i++ {
|
|
peer := &remotePeer{PrivKey: ed25519.GenPrivKey(), Config: cfg}
|
|
peers = append(peers, peer)
|
|
peer.Start()
|
|
c, err := peer.Dial(sw.NetAddress())
|
|
require.NoError(t, err)
|
|
// spawn a reading routine to prevent connection from closing
|
|
go func(c net.Conn) {
|
|
for {
|
|
one := make([]byte, 1)
|
|
_, err := c.Read(one)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}(c)
|
|
}
|
|
time.Sleep(10 * time.Millisecond)
|
|
assert.Equal(t, cfg.MaxNumInboundPeers, sw.Peers().Size())
|
|
|
|
// 2. check we close new connections if we already have MaxNumInboundPeers peers
|
|
peer := &remotePeer{PrivKey: ed25519.GenPrivKey(), Config: cfg}
|
|
peer.Start()
|
|
conn, err := peer.Dial(sw.NetAddress())
|
|
require.NoError(t, err)
|
|
// check conn is closed
|
|
one := make([]byte, 1)
|
|
conn.SetReadDeadline(time.Now().Add(10 * time.Millisecond))
|
|
_, err = conn.Read(one)
|
|
assert.Equal(t, io.EOF, err)
|
|
assert.Equal(t, cfg.MaxNumInboundPeers, sw.Peers().Size())
|
|
peer.Stop()
|
|
|
|
// 3. check we connect to unconditional peers despite the limit.
|
|
for _, peer := range unconditionalPeers {
|
|
c, err := peer.Dial(sw.NetAddress())
|
|
require.NoError(t, err)
|
|
// spawn a reading routine to prevent connection from closing
|
|
go func(c net.Conn) {
|
|
for {
|
|
one := make([]byte, 1)
|
|
_, err := c.Read(one)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}(c)
|
|
}
|
|
time.Sleep(10 * time.Millisecond)
|
|
assert.Equal(t, cfg.MaxNumInboundPeers+unconditionalPeersNum, sw.Peers().Size())
|
|
|
|
for _, peer := range peers {
|
|
peer.Stop()
|
|
}
|
|
for _, peer := range unconditionalPeers {
|
|
peer.Stop()
|
|
}
|
|
}
|
|
|
|
type errorTransport struct {
|
|
acceptErr error
|
|
}
|
|
|
|
func (et errorTransport) NetAddress() NetAddress {
|
|
panic("not implemented")
|
|
}
|
|
|
|
func (et errorTransport) Accept(c peerConfig) (Peer, error) {
|
|
return nil, et.acceptErr
|
|
}
|
|
func (errorTransport) Dial(NetAddress, peerConfig) (Peer, error) {
|
|
panic("not implemented")
|
|
}
|
|
func (errorTransport) Cleanup(Peer) {
|
|
panic("not implemented")
|
|
}
|
|
|
|
func TestSwitchAcceptRoutineErrorCases(t *testing.T) {
|
|
sw := NewSwitch(cfg, errorTransport{ErrFilterTimeout{}})
|
|
assert.NotPanics(t, func() {
|
|
err := sw.Start()
|
|
assert.NoError(t, err)
|
|
sw.Stop()
|
|
})
|
|
|
|
sw = NewSwitch(cfg, errorTransport{ErrRejected{conn: nil, err: errors.New("filtered"), isFiltered: true}})
|
|
assert.NotPanics(t, func() {
|
|
err := sw.Start()
|
|
assert.NoError(t, err)
|
|
sw.Stop()
|
|
})
|
|
// TODO(melekes) check we remove our address from addrBook
|
|
|
|
sw = NewSwitch(cfg, errorTransport{ErrTransportClosed{}})
|
|
assert.NotPanics(t, func() {
|
|
err := sw.Start()
|
|
assert.NoError(t, err)
|
|
err = sw.Stop()
|
|
require.NoError(t, err)
|
|
})
|
|
}
|
|
|
|
// mockReactor checks that InitPeer never called before RemovePeer. If that's
|
|
// not true, InitCalledBeforeRemoveFinished will return true.
|
|
type mockReactor struct {
|
|
*BaseReactor
|
|
|
|
// atomic
|
|
removePeerInProgress uint32
|
|
initCalledBeforeRemoveFinished uint32
|
|
}
|
|
|
|
func (r *mockReactor) RemovePeer(peer Peer, reason interface{}) {
|
|
atomic.StoreUint32(&r.removePeerInProgress, 1)
|
|
defer atomic.StoreUint32(&r.removePeerInProgress, 0)
|
|
time.Sleep(100 * time.Millisecond)
|
|
}
|
|
|
|
func (r *mockReactor) InitPeer(peer Peer) Peer {
|
|
if atomic.LoadUint32(&r.removePeerInProgress) == 1 {
|
|
atomic.StoreUint32(&r.initCalledBeforeRemoveFinished, 1)
|
|
}
|
|
|
|
return peer
|
|
}
|
|
|
|
func (r *mockReactor) InitCalledBeforeRemoveFinished() bool {
|
|
return atomic.LoadUint32(&r.initCalledBeforeRemoveFinished) == 1
|
|
}
|
|
|
|
// see stopAndRemovePeer
|
|
func TestSwitchInitPeerIsNotCalledBeforeRemovePeer(t *testing.T) {
|
|
// make reactor
|
|
reactor := &mockReactor{}
|
|
reactor.BaseReactor = NewBaseReactor("mockReactor", reactor)
|
|
|
|
// make switch
|
|
sw := MakeSwitch(cfg, 1, "testing", "123.123.123", func(i int, sw *Switch) *Switch {
|
|
sw.AddReactor("mock", reactor)
|
|
return sw
|
|
})
|
|
err := sw.Start()
|
|
require.NoError(t, err)
|
|
defer sw.Stop()
|
|
|
|
// add peer
|
|
rp := &remotePeer{PrivKey: ed25519.GenPrivKey(), Config: cfg}
|
|
rp.Start()
|
|
defer rp.Stop()
|
|
_, err = rp.Dial(sw.NetAddress())
|
|
require.NoError(t, err)
|
|
|
|
// wait till the switch adds rp to the peer set, then stop the peer asynchronously
|
|
for {
|
|
time.Sleep(20 * time.Millisecond)
|
|
if peer := sw.Peers().Get(rp.ID()); peer != nil {
|
|
go sw.StopPeerForError(peer, "test")
|
|
break
|
|
}
|
|
}
|
|
|
|
// simulate peer reconnecting to us
|
|
_, err = rp.Dial(sw.NetAddress())
|
|
require.NoError(t, err)
|
|
// wait till the switch adds rp to the peer set
|
|
time.Sleep(50 * time.Millisecond)
|
|
|
|
// make sure reactor.RemovePeer is finished before InitPeer is called
|
|
assert.False(t, reactor.InitCalledBeforeRemoveFinished())
|
|
}
|
|
|
|
func BenchmarkSwitchBroadcast(b *testing.B) {
|
|
s1, s2 := MakeSwitchPair(b, func(i int, sw *Switch) *Switch {
|
|
// Make bar reactors of bar channels each
|
|
sw.AddReactor("foo", NewTestReactor([]*conn.ChannelDescriptor{
|
|
{ID: byte(0x00), Priority: 10},
|
|
{ID: byte(0x01), Priority: 10},
|
|
}, false))
|
|
sw.AddReactor("bar", NewTestReactor([]*conn.ChannelDescriptor{
|
|
{ID: byte(0x02), Priority: 10},
|
|
{ID: byte(0x03), Priority: 10},
|
|
}, false))
|
|
return sw
|
|
})
|
|
|
|
b.Cleanup(func() {
|
|
if err := s1.Stop(); err != nil {
|
|
b.Error(err)
|
|
}
|
|
})
|
|
|
|
b.Cleanup(func() {
|
|
if err := s2.Stop(); err != nil {
|
|
b.Error(err)
|
|
}
|
|
})
|
|
|
|
// Allow time for goroutines to boot up
|
|
time.Sleep(1 * time.Second)
|
|
|
|
b.ResetTimer()
|
|
|
|
numSuccess, numFailure := 0, 0
|
|
|
|
// Send random message from foo channel to another
|
|
for i := 0; i < b.N; i++ {
|
|
chID := byte(i % 4)
|
|
successChan := s1.Broadcast(chID, []byte("test data"))
|
|
for s := range successChan {
|
|
if s {
|
|
numSuccess++
|
|
} else {
|
|
numFailure++
|
|
}
|
|
}
|
|
}
|
|
|
|
b.Logf("success: %v, failure: %v", numSuccess, numFailure)
|
|
}
|