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.
381 lines
9.6 KiB
381 lines
9.6 KiB
package p2p
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
golog "log"
|
|
"net"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
. "github.com/tendermint/go-common"
|
|
cmn "github.com/tendermint/go-common"
|
|
cfg "github.com/tendermint/go-config"
|
|
crypto "github.com/tendermint/go-crypto"
|
|
wire "github.com/tendermint/go-wire"
|
|
)
|
|
|
|
var (
|
|
config cfg.Config
|
|
)
|
|
|
|
func init() {
|
|
config = cfg.NewMapConfig(nil)
|
|
setConfigDefaults(config)
|
|
}
|
|
|
|
type PeerMessage struct {
|
|
PeerKey string
|
|
Bytes []byte
|
|
Counter int
|
|
}
|
|
|
|
type TestReactor struct {
|
|
BaseReactor
|
|
|
|
mtx sync.Mutex
|
|
channels []*ChannelDescriptor
|
|
peersAdded []*Peer
|
|
peersRemoved []*Peer
|
|
logMessages bool
|
|
msgsCounter int
|
|
msgsReceived map[byte][]PeerMessage
|
|
}
|
|
|
|
func NewTestReactor(channels []*ChannelDescriptor, logMessages bool) *TestReactor {
|
|
tr := &TestReactor{
|
|
channels: channels,
|
|
logMessages: logMessages,
|
|
msgsReceived: make(map[byte][]PeerMessage),
|
|
}
|
|
tr.BaseReactor = *NewBaseReactor(log, "TestReactor", tr)
|
|
return tr
|
|
}
|
|
|
|
func (tr *TestReactor) GetChannels() []*ChannelDescriptor {
|
|
return tr.channels
|
|
}
|
|
|
|
func (tr *TestReactor) AddPeer(peer *Peer) {
|
|
tr.mtx.Lock()
|
|
defer tr.mtx.Unlock()
|
|
tr.peersAdded = append(tr.peersAdded, peer)
|
|
}
|
|
|
|
func (tr *TestReactor) RemovePeer(peer *Peer, reason interface{}) {
|
|
tr.mtx.Lock()
|
|
defer tr.mtx.Unlock()
|
|
tr.peersRemoved = append(tr.peersRemoved, peer)
|
|
}
|
|
|
|
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.Key, 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(2, initSwitch, Connect2Switches)
|
|
return switches[0], switches[1]
|
|
}
|
|
|
|
func initSwitchFunc(i int, sw *Switch) *Switch {
|
|
// Make two reactors of two channels each
|
|
sw.AddReactor("foo", NewTestReactor([]*ChannelDescriptor{
|
|
&ChannelDescriptor{ID: byte(0x00), Priority: 10},
|
|
&ChannelDescriptor{ID: byte(0x01), Priority: 10},
|
|
}, true))
|
|
sw.AddReactor("bar", NewTestReactor([]*ChannelDescriptor{
|
|
&ChannelDescriptor{ID: byte(0x02), Priority: 10},
|
|
&ChannelDescriptor{ID: byte(0x03), Priority: 10},
|
|
}, true))
|
|
return sw
|
|
}
|
|
|
|
func TestSwitches(t *testing.T) {
|
|
s1, s2 := makeSwitchPair(t, initSwitchFunc)
|
|
defer s1.Stop()
|
|
defer s2.Stop()
|
|
|
|
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 := "channel zero"
|
|
ch1Msg := "channel foo"
|
|
ch2Msg := "channel bar"
|
|
|
|
s1.Broadcast(byte(0x00), ch0Msg)
|
|
s1.Broadcast(byte(0x01), ch1Msg)
|
|
s1.Broadcast(byte(0x02), ch2Msg)
|
|
|
|
// Wait for things to settle...
|
|
time.Sleep(5000 * time.Millisecond)
|
|
|
|
// Check message on ch0
|
|
ch0Msgs := s2.Reactor("foo").(*TestReactor).getMsgs(byte(0x00))
|
|
if len(ch0Msgs) != 1 {
|
|
t.Errorf("Expected to have received 1 message in ch0")
|
|
}
|
|
if !bytes.Equal(ch0Msgs[0].Bytes, wire.BinaryBytes(ch0Msg)) {
|
|
t.Errorf("Unexpected message bytes. Wanted: %X, Got: %X", wire.BinaryBytes(ch0Msg), ch0Msgs[0].Bytes)
|
|
}
|
|
|
|
// Check message on ch1
|
|
ch1Msgs := s2.Reactor("foo").(*TestReactor).getMsgs(byte(0x01))
|
|
if len(ch1Msgs) != 1 {
|
|
t.Errorf("Expected to have received 1 message in ch1")
|
|
}
|
|
if !bytes.Equal(ch1Msgs[0].Bytes, wire.BinaryBytes(ch1Msg)) {
|
|
t.Errorf("Unexpected message bytes. Wanted: %X, Got: %X", wire.BinaryBytes(ch1Msg), ch1Msgs[0].Bytes)
|
|
}
|
|
|
|
// Check message on ch2
|
|
ch2Msgs := s2.Reactor("bar").(*TestReactor).getMsgs(byte(0x02))
|
|
if len(ch2Msgs) != 1 {
|
|
t.Errorf("Expected to have received 1 message in ch2")
|
|
}
|
|
if !bytes.Equal(ch2Msgs[0].Bytes, wire.BinaryBytes(ch2Msg)) {
|
|
t.Errorf("Unexpected message bytes. Wanted: %X, Got: %X", wire.BinaryBytes(ch2Msg), ch2Msgs[0].Bytes)
|
|
}
|
|
|
|
}
|
|
|
|
func TestConnAddrFilter(t *testing.T) {
|
|
s1 := makeSwitch(1, "testing", "123.123.123", initSwitchFunc)
|
|
s2 := makeSwitch(1, "testing", "123.123.123", initSwitchFunc)
|
|
|
|
c1, c2 := net.Pipe()
|
|
|
|
s1.SetAddrFilter(func(addr net.Addr) error {
|
|
if addr.String() == c1.RemoteAddr().String() {
|
|
return fmt.Errorf("Error: pipe is blacklisted")
|
|
}
|
|
return nil
|
|
})
|
|
|
|
// connect to good peer
|
|
go func() {
|
|
s1.AddPeerWithConnection(c1, false)
|
|
}()
|
|
go func() {
|
|
s2.AddPeerWithConnection(c2, true)
|
|
}()
|
|
|
|
// Wait for things to happen, peers to get added...
|
|
time.Sleep(100 * time.Millisecond * time.Duration(4))
|
|
|
|
defer s1.Stop()
|
|
defer s2.Stop()
|
|
if s1.Peers().Size() != 0 {
|
|
t.Errorf("Expected s1 not to connect to peers, got %d", s1.Peers().Size())
|
|
}
|
|
if s2.Peers().Size() != 0 {
|
|
t.Errorf("Expected s2 not to connect to peers, got %d", s2.Peers().Size())
|
|
}
|
|
}
|
|
|
|
func TestConnPubKeyFilter(t *testing.T) {
|
|
s1 := makeSwitch(1, "testing", "123.123.123", initSwitchFunc)
|
|
s2 := makeSwitch(1, "testing", "123.123.123", initSwitchFunc)
|
|
|
|
c1, c2 := net.Pipe()
|
|
|
|
// set pubkey filter
|
|
s1.SetPubKeyFilter(func(pubkey crypto.PubKeyEd25519) error {
|
|
if bytes.Equal(pubkey.Bytes(), s2.nodeInfo.PubKey.Bytes()) {
|
|
return fmt.Errorf("Error: pipe is blacklisted")
|
|
}
|
|
return nil
|
|
})
|
|
|
|
// connect to good peer
|
|
go func() {
|
|
s1.AddPeerWithConnection(c1, false)
|
|
}()
|
|
go func() {
|
|
s2.AddPeerWithConnection(c2, true)
|
|
}()
|
|
|
|
// Wait for things to happen, peers to get added...
|
|
time.Sleep(100 * time.Millisecond * time.Duration(4))
|
|
|
|
defer s1.Stop()
|
|
defer s2.Stop()
|
|
if s1.Peers().Size() != 0 {
|
|
t.Errorf("Expected s1 not to connect to peers, got %d", s1.Peers().Size())
|
|
}
|
|
if s2.Peers().Size() != 0 {
|
|
t.Errorf("Expected s2 not to connect to peers, got %d", s2.Peers().Size())
|
|
}
|
|
}
|
|
|
|
func TestSwitchStopsNonPersistentPeerOnError(t *testing.T) {
|
|
assert, require := assert.New(t), require.New(t)
|
|
|
|
sw := makeSwitch(1, "testing", "123.123.123", initSwitchFunc)
|
|
sw.Start()
|
|
defer sw.Stop()
|
|
|
|
sw2 := makeSwitch(2, "testing", "123.123.123", initSwitchFunc)
|
|
defer sw2.Stop()
|
|
l, serverAddr := listenTCP()
|
|
done := make(chan struct{})
|
|
go accept(l, done, sw2)
|
|
defer close(done)
|
|
|
|
peer, err := newPeer(NewNetAddress(serverAddr), sw.reactorsByCh, sw.chDescs, sw.StopPeerForError, sw.config, sw.nodePrivKey)
|
|
require.Nil(err)
|
|
err = sw.AddPeer(peer)
|
|
require.Nil(err)
|
|
|
|
// simulate failure by closing connection
|
|
peer.CloseConn()
|
|
|
|
time.Sleep(100 * time.Millisecond)
|
|
|
|
assert.Zero(sw.Peers().Size())
|
|
assert.False(peer.IsRunning())
|
|
}
|
|
|
|
func TestSwitchReconnectsToPersistentPeer(t *testing.T) {
|
|
assert, require := assert.New(t), require.New(t)
|
|
|
|
sw := makeSwitch(1, "testing", "123.123.123", initSwitchFunc)
|
|
sw.Start()
|
|
defer sw.Stop()
|
|
|
|
sw2 := makeSwitch(2, "testing", "123.123.123", initSwitchFunc)
|
|
defer sw2.Stop()
|
|
l, serverAddr := listenTCP()
|
|
done := make(chan struct{})
|
|
go accept(l, done, sw2)
|
|
defer close(done)
|
|
|
|
peer, err := newPeer(NewNetAddress(serverAddr), sw.reactorsByCh, sw.chDescs, sw.StopPeerForError, sw.config, sw.nodePrivKey)
|
|
peer.makePersistent()
|
|
require.Nil(err)
|
|
err = sw.AddPeer(peer)
|
|
require.Nil(err)
|
|
|
|
// simulate failure by closing connection
|
|
peer.CloseConn()
|
|
|
|
time.Sleep(100 * time.Millisecond)
|
|
|
|
assert.NotZero(sw.Peers().Size())
|
|
assert.False(peer.IsRunning())
|
|
}
|
|
|
|
func BenchmarkSwitches(b *testing.B) {
|
|
|
|
b.StopTimer()
|
|
|
|
s1, s2 := makeSwitchPair(b, func(i int, sw *Switch) *Switch {
|
|
// Make bar reactors of bar channels each
|
|
sw.AddReactor("foo", NewTestReactor([]*ChannelDescriptor{
|
|
&ChannelDescriptor{ID: byte(0x00), Priority: 10},
|
|
&ChannelDescriptor{ID: byte(0x01), Priority: 10},
|
|
}, false))
|
|
sw.AddReactor("bar", NewTestReactor([]*ChannelDescriptor{
|
|
&ChannelDescriptor{ID: byte(0x02), Priority: 10},
|
|
&ChannelDescriptor{ID: byte(0x03), Priority: 10},
|
|
}, false))
|
|
return sw
|
|
})
|
|
defer s1.Stop()
|
|
defer s2.Stop()
|
|
|
|
// Allow time for goroutines to boot up
|
|
time.Sleep(1000 * time.Millisecond)
|
|
b.StartTimer()
|
|
|
|
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, "test data")
|
|
for s := range successChan {
|
|
if s {
|
|
numSuccess++
|
|
} else {
|
|
numFailure++
|
|
}
|
|
}
|
|
}
|
|
|
|
log.Warn(Fmt("success: %v, failure: %v", numSuccess, numFailure))
|
|
|
|
// Allow everything to flush before stopping switches & closing connections.
|
|
b.StopTimer()
|
|
time.Sleep(1000 * time.Millisecond)
|
|
|
|
}
|
|
|
|
func listenTCP() (net.Listener, net.Addr) {
|
|
l, e := net.Listen("tcp", "127.0.0.1:0") // any available address
|
|
if e != nil {
|
|
golog.Fatalf("net.Listen tcp :0: %+v", e)
|
|
}
|
|
return l, l.Addr()
|
|
}
|
|
|
|
// simulate remote peer
|
|
func accept(l net.Listener, done <-chan struct{}, sw *Switch) {
|
|
for {
|
|
conn, err := l.Accept()
|
|
if err != nil {
|
|
golog.Fatalf("Failed to accept conn: %+v", err)
|
|
}
|
|
conn, err = MakeSecretConnection(conn, sw.nodePrivKey)
|
|
if err != nil {
|
|
golog.Fatalf("Failed to make secret conn: %+v", err)
|
|
}
|
|
var err1, err2 error
|
|
nodeInfo := new(NodeInfo)
|
|
cmn.Parallel(
|
|
func() {
|
|
var n int
|
|
wire.WriteBinary(sw.nodeInfo, conn, &n, &err1)
|
|
},
|
|
func() {
|
|
var n int
|
|
wire.ReadBinary(nodeInfo, conn, maxNodeInfoSize, &n, &err2)
|
|
})
|
|
if err1 != nil {
|
|
golog.Fatalf("Failed to do handshake: %+v", err1)
|
|
}
|
|
if err2 != nil {
|
|
golog.Fatalf("Failed to do handshake: %+v", err2)
|
|
}
|
|
select {
|
|
case <-done:
|
|
conn.Close()
|
|
return
|
|
default:
|
|
}
|
|
}
|
|
}
|