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.
818 lines
22 KiB
818 lines
22 KiB
package pex_test
|
|
|
|
import (
|
|
"context"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/require"
|
|
dbm "github.com/tendermint/tm-db"
|
|
|
|
"github.com/tendermint/tendermint/crypto/ed25519"
|
|
"github.com/tendermint/tendermint/internal/p2p"
|
|
"github.com/tendermint/tendermint/internal/p2p/p2ptest"
|
|
"github.com/tendermint/tendermint/internal/p2p/pex"
|
|
"github.com/tendermint/tendermint/libs/log"
|
|
p2pproto "github.com/tendermint/tendermint/proto/tendermint/p2p"
|
|
"github.com/tendermint/tendermint/types"
|
|
)
|
|
|
|
const (
|
|
checkFrequency = 500 * time.Millisecond
|
|
defaultBufferSize = 2
|
|
shortWait = 10 * time.Second
|
|
longWait = 60 * time.Second
|
|
|
|
firstNode = 0
|
|
secondNode = 1
|
|
thirdNode = 2
|
|
fourthNode = 3
|
|
)
|
|
|
|
func TestReactorBasic(t *testing.T) {
|
|
// start a network with one mock reactor and one "real" reactor
|
|
testNet := setupNetwork(t, testOptions{
|
|
MockNodes: 1,
|
|
TotalNodes: 2,
|
|
})
|
|
testNet.connectAll(t)
|
|
testNet.start(t)
|
|
|
|
// assert that the mock node receives a request from the real node
|
|
testNet.listenForRequest(t, secondNode, firstNode, shortWait)
|
|
|
|
// assert that when a mock node sends a request it receives a response (and
|
|
// the correct one)
|
|
testNet.sendRequest(t, firstNode, secondNode, true)
|
|
testNet.listenForResponse(t, secondNode, firstNode, shortWait, []p2pproto.PexAddressV2(nil))
|
|
}
|
|
|
|
func TestReactorConnectFullNetwork(t *testing.T) {
|
|
testNet := setupNetwork(t, testOptions{
|
|
TotalNodes: 4,
|
|
})
|
|
|
|
// make every node be only connected with one other node (it actually ends up
|
|
// being two because of two way connections but oh well)
|
|
testNet.connectN(t, 1)
|
|
testNet.start(t)
|
|
|
|
// assert that all nodes add each other in the network
|
|
for idx := 0; idx < len(testNet.nodes); idx++ {
|
|
testNet.requireNumberOfPeers(t, idx, len(testNet.nodes)-1, longWait)
|
|
}
|
|
}
|
|
|
|
func TestReactorSendsRequestsTooOften(t *testing.T) {
|
|
r := setupSingle(t)
|
|
|
|
badNode := newNodeID(t, "b")
|
|
|
|
r.pexInCh <- p2p.Envelope{
|
|
From: badNode,
|
|
Message: &p2pproto.PexRequestV2{},
|
|
}
|
|
|
|
resp := <-r.pexOutCh
|
|
msg, ok := resp.Message.(*p2pproto.PexResponseV2)
|
|
require.True(t, ok)
|
|
require.Empty(t, msg.Addresses)
|
|
|
|
r.pexInCh <- p2p.Envelope{
|
|
From: badNode,
|
|
Message: &p2pproto.PexRequestV2{},
|
|
}
|
|
|
|
peerErr := <-r.pexErrCh
|
|
require.Error(t, peerErr.Err)
|
|
require.Empty(t, r.pexOutCh)
|
|
require.Contains(t, peerErr.Err.Error(), "peer sent a request too close after a prior one")
|
|
require.Equal(t, badNode, peerErr.NodeID)
|
|
}
|
|
|
|
func TestReactorSendsResponseWithoutRequest(t *testing.T) {
|
|
testNet := setupNetwork(t, testOptions{
|
|
MockNodes: 1,
|
|
TotalNodes: 3,
|
|
})
|
|
testNet.connectAll(t)
|
|
testNet.start(t)
|
|
|
|
// firstNode sends the secondNode an unrequested response
|
|
// NOTE: secondNode will send a request by default during startup so we send
|
|
// two responses to counter that.
|
|
testNet.sendResponse(t, firstNode, secondNode, []int{thirdNode}, true)
|
|
testNet.sendResponse(t, firstNode, secondNode, []int{thirdNode}, true)
|
|
|
|
// secondNode should evict the firstNode
|
|
testNet.listenForPeerUpdate(t, secondNode, firstNode, p2p.PeerStatusDown, shortWait)
|
|
}
|
|
|
|
func TestReactorNeverSendsTooManyPeers(t *testing.T) {
|
|
testNet := setupNetwork(t, testOptions{
|
|
MockNodes: 1,
|
|
TotalNodes: 2,
|
|
})
|
|
testNet.connectAll(t)
|
|
testNet.start(t)
|
|
|
|
testNet.addNodes(t, 110)
|
|
nodes := make([]int, 110)
|
|
for i := 0; i < len(nodes); i++ {
|
|
nodes[i] = i + 2
|
|
}
|
|
testNet.addAddresses(t, secondNode, nodes)
|
|
|
|
// first we check that even although we have 110 peers, honest pex reactors
|
|
// only send 100 (test if secondNode sends firstNode 100 addresses)
|
|
testNet.pingAndlistenForNAddresses(t, secondNode, firstNode, shortWait, 100)
|
|
}
|
|
|
|
func TestReactorErrorsOnReceivingTooManyPeers(t *testing.T) {
|
|
r := setupSingle(t)
|
|
peer := p2p.NodeAddress{Protocol: p2p.MemoryProtocol, NodeID: randomNodeID(t)}
|
|
added, err := r.manager.Add(peer)
|
|
require.NoError(t, err)
|
|
require.True(t, added)
|
|
|
|
addresses := make([]p2pproto.PexAddressV2, 101)
|
|
for i := 0; i < len(addresses); i++ {
|
|
nodeAddress := p2p.NodeAddress{Protocol: p2p.MemoryProtocol, NodeID: randomNodeID(t)}
|
|
addresses[i] = p2pproto.PexAddressV2{
|
|
URL: nodeAddress.String(),
|
|
}
|
|
}
|
|
|
|
r.peerCh <- p2p.PeerUpdate{
|
|
NodeID: peer.NodeID,
|
|
Status: p2p.PeerStatusUp,
|
|
}
|
|
|
|
select {
|
|
// wait for a request and then send a response with too many addresses
|
|
case req := <-r.pexOutCh:
|
|
if _, ok := req.Message.(*p2pproto.PexRequestV2); !ok {
|
|
t.Fatal("expected v2 pex request")
|
|
}
|
|
r.pexInCh <- p2p.Envelope{
|
|
From: peer.NodeID,
|
|
Message: &p2pproto.PexResponseV2{
|
|
Addresses: addresses,
|
|
},
|
|
}
|
|
|
|
case <-time.After(10 * time.Second):
|
|
t.Fatal("pex failed to send a request within 10 seconds")
|
|
}
|
|
|
|
peerErr := <-r.pexErrCh
|
|
require.Error(t, peerErr.Err)
|
|
require.Empty(t, r.pexOutCh)
|
|
require.Contains(t, peerErr.Err.Error(), "peer sent too many addresses")
|
|
require.Equal(t, peer.NodeID, peerErr.NodeID)
|
|
}
|
|
|
|
func TestReactorSmallPeerStoreInALargeNetwork(t *testing.T) {
|
|
testNet := setupNetwork(t, testOptions{
|
|
TotalNodes: 8,
|
|
MaxPeers: 4,
|
|
MaxConnected: 3,
|
|
BufferSize: 8,
|
|
})
|
|
testNet.connectN(t, 1)
|
|
testNet.start(t)
|
|
|
|
// test that all nodes reach full capacity
|
|
for _, nodeID := range testNet.nodes {
|
|
require.Eventually(t, func() bool {
|
|
// nolint:scopelint
|
|
return testNet.network.Nodes[nodeID].PeerManager.PeerRatio() >= 0.9
|
|
}, longWait, checkFrequency)
|
|
}
|
|
}
|
|
|
|
func TestReactorLargePeerStoreInASmallNetwork(t *testing.T) {
|
|
testNet := setupNetwork(t, testOptions{
|
|
TotalNodes: 3,
|
|
MaxPeers: 25,
|
|
MaxConnected: 25,
|
|
BufferSize: 5,
|
|
})
|
|
testNet.connectN(t, 1)
|
|
testNet.start(t)
|
|
|
|
// assert that all nodes add each other in the network
|
|
for idx := 0; idx < len(testNet.nodes); idx++ {
|
|
testNet.requireNumberOfPeers(t, idx, len(testNet.nodes)-1, longWait)
|
|
}
|
|
}
|
|
|
|
func TestReactorWithNetworkGrowth(t *testing.T) {
|
|
testNet := setupNetwork(t, testOptions{
|
|
TotalNodes: 5,
|
|
BufferSize: 5,
|
|
})
|
|
testNet.connectAll(t)
|
|
testNet.start(t)
|
|
|
|
// assert that all nodes add each other in the network
|
|
for idx := 0; idx < len(testNet.nodes); idx++ {
|
|
testNet.requireNumberOfPeers(t, idx, len(testNet.nodes)-1, shortWait)
|
|
}
|
|
|
|
// now we inject 10 more nodes
|
|
testNet.addNodes(t, 10)
|
|
for i := 5; i < testNet.total; i++ {
|
|
node := testNet.nodes[i]
|
|
require.NoError(t, testNet.reactors[node].Start())
|
|
require.True(t, testNet.reactors[node].IsRunning())
|
|
// we connect all new nodes to a single entry point and check that the
|
|
// node can distribute the addresses to all the others
|
|
testNet.connectPeers(t, 0, i)
|
|
}
|
|
require.Len(t, testNet.reactors, 15)
|
|
|
|
// assert that all nodes add each other in the network
|
|
for idx := 0; idx < len(testNet.nodes); idx++ {
|
|
testNet.requireNumberOfPeers(t, idx, len(testNet.nodes)-1, longWait)
|
|
}
|
|
}
|
|
|
|
func TestReactorIntegrationWithLegacyHandleRequest(t *testing.T) {
|
|
testNet := setupNetwork(t, testOptions{
|
|
MockNodes: 1,
|
|
TotalNodes: 3,
|
|
})
|
|
testNet.connectAll(t)
|
|
testNet.start(t)
|
|
t.Log(testNet.nodes)
|
|
|
|
// mock node sends a V1 Pex message to the second node
|
|
testNet.sendRequest(t, firstNode, secondNode, false)
|
|
addrs := testNet.getAddressesFor(t, []int{thirdNode})
|
|
testNet.listenForLegacyResponse(t, secondNode, firstNode, shortWait, addrs)
|
|
}
|
|
|
|
func TestReactorIntegrationWithLegacyHandleResponse(t *testing.T) {
|
|
testNet := setupNetwork(t, testOptions{
|
|
MockNodes: 1,
|
|
TotalNodes: 4,
|
|
BufferSize: 4,
|
|
})
|
|
testNet.connectPeers(t, firstNode, secondNode)
|
|
testNet.connectPeers(t, firstNode, thirdNode)
|
|
testNet.connectPeers(t, firstNode, fourthNode)
|
|
testNet.start(t)
|
|
|
|
testNet.listenForRequest(t, secondNode, firstNode, shortWait)
|
|
// send a v1 response instead
|
|
testNet.sendResponse(t, firstNode, secondNode, []int{thirdNode, fourthNode}, false)
|
|
testNet.requireNumberOfPeers(t, secondNode, len(testNet.nodes)-1, shortWait)
|
|
}
|
|
|
|
type singleTestReactor struct {
|
|
reactor *pex.ReactorV2
|
|
pexInCh chan p2p.Envelope
|
|
pexOutCh chan p2p.Envelope
|
|
pexErrCh chan p2p.PeerError
|
|
pexCh *p2p.Channel
|
|
peerCh chan p2p.PeerUpdate
|
|
manager *p2p.PeerManager
|
|
}
|
|
|
|
func setupSingle(t *testing.T) *singleTestReactor {
|
|
t.Helper()
|
|
nodeID := newNodeID(t, "a")
|
|
chBuf := 2
|
|
pexInCh := make(chan p2p.Envelope, chBuf)
|
|
pexOutCh := make(chan p2p.Envelope, chBuf)
|
|
pexErrCh := make(chan p2p.PeerError, chBuf)
|
|
pexCh := p2p.NewChannel(
|
|
p2p.ChannelID(pex.PexChannel),
|
|
new(p2pproto.PexMessage),
|
|
pexInCh,
|
|
pexOutCh,
|
|
pexErrCh,
|
|
)
|
|
|
|
peerCh := make(chan p2p.PeerUpdate, chBuf)
|
|
peerUpdates := p2p.NewPeerUpdates(peerCh, chBuf)
|
|
peerManager, err := p2p.NewPeerManager(nodeID, dbm.NewMemDB(), p2p.PeerManagerOptions{})
|
|
require.NoError(t, err)
|
|
|
|
reactor := pex.NewReactorV2(log.TestingLogger(), peerManager, pexCh, peerUpdates)
|
|
require.NoError(t, reactor.Start())
|
|
t.Cleanup(func() {
|
|
err := reactor.Stop()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
pexCh.Close()
|
|
peerUpdates.Close()
|
|
})
|
|
|
|
return &singleTestReactor{
|
|
reactor: reactor,
|
|
pexInCh: pexInCh,
|
|
pexOutCh: pexOutCh,
|
|
pexErrCh: pexErrCh,
|
|
pexCh: pexCh,
|
|
peerCh: peerCh,
|
|
manager: peerManager,
|
|
}
|
|
}
|
|
|
|
type reactorTestSuite struct {
|
|
network *p2ptest.Network
|
|
logger log.Logger
|
|
|
|
reactors map[types.NodeID]*pex.ReactorV2
|
|
pexChannels map[types.NodeID]*p2p.Channel
|
|
|
|
peerChans map[types.NodeID]chan p2p.PeerUpdate
|
|
peerUpdates map[types.NodeID]*p2p.PeerUpdates
|
|
|
|
nodes []types.NodeID
|
|
mocks []types.NodeID
|
|
total int
|
|
opts testOptions
|
|
}
|
|
|
|
type testOptions struct {
|
|
MockNodes int
|
|
TotalNodes int
|
|
BufferSize int
|
|
MaxPeers uint16
|
|
MaxConnected uint16
|
|
}
|
|
|
|
// setup setups a test suite with a network of nodes. Mocknodes represent the
|
|
// hollow nodes that the test can listen and send on
|
|
func setupNetwork(t *testing.T, opts testOptions) *reactorTestSuite {
|
|
t.Helper()
|
|
|
|
require.Greater(t, opts.TotalNodes, opts.MockNodes)
|
|
if opts.BufferSize == 0 {
|
|
opts.BufferSize = defaultBufferSize
|
|
}
|
|
networkOpts := p2ptest.NetworkOptions{
|
|
NumNodes: opts.TotalNodes,
|
|
BufferSize: opts.BufferSize,
|
|
NodeOpts: p2ptest.NodeOptions{
|
|
MaxPeers: opts.MaxPeers,
|
|
MaxConnected: opts.MaxConnected,
|
|
},
|
|
}
|
|
chBuf := opts.BufferSize
|
|
realNodes := opts.TotalNodes - opts.MockNodes
|
|
|
|
rts := &reactorTestSuite{
|
|
logger: log.TestingLogger().With("testCase", t.Name()),
|
|
network: p2ptest.MakeNetwork(t, networkOpts),
|
|
reactors: make(map[types.NodeID]*pex.ReactorV2, realNodes),
|
|
pexChannels: make(map[types.NodeID]*p2p.Channel, opts.TotalNodes),
|
|
peerChans: make(map[types.NodeID]chan p2p.PeerUpdate, opts.TotalNodes),
|
|
peerUpdates: make(map[types.NodeID]*p2p.PeerUpdates, opts.TotalNodes),
|
|
total: opts.TotalNodes,
|
|
opts: opts,
|
|
}
|
|
|
|
// NOTE: we don't assert that the channels get drained after stopping the
|
|
// reactor
|
|
rts.pexChannels = rts.network.MakeChannelsNoCleanup(
|
|
t, pex.ChannelDescriptor(), new(p2pproto.PexMessage), chBuf,
|
|
)
|
|
|
|
idx := 0
|
|
for nodeID := range rts.network.Nodes {
|
|
rts.peerChans[nodeID] = make(chan p2p.PeerUpdate, chBuf)
|
|
rts.peerUpdates[nodeID] = p2p.NewPeerUpdates(rts.peerChans[nodeID], chBuf)
|
|
rts.network.Nodes[nodeID].PeerManager.Register(rts.peerUpdates[nodeID])
|
|
|
|
// the first nodes in the array are always mock nodes
|
|
if idx < opts.MockNodes {
|
|
rts.mocks = append(rts.mocks, nodeID)
|
|
} else {
|
|
rts.reactors[nodeID] = pex.NewReactorV2(
|
|
rts.logger.With("nodeID", nodeID),
|
|
rts.network.Nodes[nodeID].PeerManager,
|
|
rts.pexChannels[nodeID],
|
|
rts.peerUpdates[nodeID],
|
|
)
|
|
}
|
|
rts.nodes = append(rts.nodes, nodeID)
|
|
|
|
idx++
|
|
}
|
|
|
|
require.Len(t, rts.reactors, realNodes)
|
|
|
|
t.Cleanup(func() {
|
|
for nodeID, reactor := range rts.reactors {
|
|
if reactor.IsRunning() {
|
|
require.NoError(t, reactor.Stop())
|
|
require.False(t, reactor.IsRunning())
|
|
}
|
|
rts.pexChannels[nodeID].Close()
|
|
rts.peerUpdates[nodeID].Close()
|
|
}
|
|
for _, nodeID := range rts.mocks {
|
|
rts.pexChannels[nodeID].Close()
|
|
rts.peerUpdates[nodeID].Close()
|
|
}
|
|
})
|
|
|
|
return rts
|
|
}
|
|
|
|
// starts up the pex reactors for each node
|
|
func (r *reactorTestSuite) start(t *testing.T) {
|
|
t.Helper()
|
|
|
|
for _, reactor := range r.reactors {
|
|
require.NoError(t, reactor.Start())
|
|
require.True(t, reactor.IsRunning())
|
|
}
|
|
}
|
|
|
|
func (r *reactorTestSuite) addNodes(t *testing.T, nodes int) {
|
|
t.Helper()
|
|
|
|
for i := 0; i < nodes; i++ {
|
|
node := r.network.MakeNode(t, p2ptest.NodeOptions{
|
|
MaxPeers: r.opts.MaxPeers,
|
|
MaxConnected: r.opts.MaxConnected,
|
|
})
|
|
r.network.Nodes[node.NodeID] = node
|
|
nodeID := node.NodeID
|
|
r.pexChannels[nodeID] = node.MakeChannelNoCleanup(
|
|
t, pex.ChannelDescriptor(), new(p2pproto.PexMessage), r.opts.BufferSize,
|
|
)
|
|
r.peerChans[nodeID] = make(chan p2p.PeerUpdate, r.opts.BufferSize)
|
|
r.peerUpdates[nodeID] = p2p.NewPeerUpdates(r.peerChans[nodeID], r.opts.BufferSize)
|
|
r.network.Nodes[nodeID].PeerManager.Register(r.peerUpdates[nodeID])
|
|
r.reactors[nodeID] = pex.NewReactorV2(
|
|
r.logger.With("nodeID", nodeID),
|
|
r.network.Nodes[nodeID].PeerManager,
|
|
r.pexChannels[nodeID],
|
|
r.peerUpdates[nodeID],
|
|
)
|
|
r.nodes = append(r.nodes, nodeID)
|
|
r.total++
|
|
}
|
|
}
|
|
|
|
func (r *reactorTestSuite) listenFor(
|
|
t *testing.T,
|
|
node types.NodeID,
|
|
conditional func(msg p2p.Envelope) bool,
|
|
assertion func(t *testing.T, msg p2p.Envelope) bool,
|
|
waitPeriod time.Duration,
|
|
) {
|
|
timesUp := time.After(waitPeriod)
|
|
for {
|
|
select {
|
|
case envelope := <-r.pexChannels[node].In:
|
|
if conditional(envelope) && assertion(t, envelope) {
|
|
return
|
|
}
|
|
case <-timesUp:
|
|
require.Fail(t, "timed out waiting for message",
|
|
"node=%v, waitPeriod=%s", node, waitPeriod)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (r *reactorTestSuite) listenForRequest(t *testing.T, fromNode, toNode int, waitPeriod time.Duration) {
|
|
r.logger.Info("Listening for request", "from", fromNode, "to", toNode)
|
|
to, from := r.checkNodePair(t, toNode, fromNode)
|
|
conditional := func(msg p2p.Envelope) bool {
|
|
_, ok := msg.Message.(*p2pproto.PexRequestV2)
|
|
return ok && msg.From == from
|
|
}
|
|
assertion := func(t *testing.T, msg p2p.Envelope) bool {
|
|
require.Equal(t, &p2pproto.PexRequestV2{}, msg.Message)
|
|
return true
|
|
}
|
|
r.listenFor(t, to, conditional, assertion, waitPeriod)
|
|
}
|
|
|
|
func (r *reactorTestSuite) pingAndlistenForNAddresses(
|
|
t *testing.T,
|
|
fromNode, toNode int,
|
|
waitPeriod time.Duration,
|
|
addresses int,
|
|
) {
|
|
r.logger.Info("Listening for addresses", "from", fromNode, "to", toNode)
|
|
to, from := r.checkNodePair(t, toNode, fromNode)
|
|
conditional := func(msg p2p.Envelope) bool {
|
|
_, ok := msg.Message.(*p2pproto.PexResponseV2)
|
|
return ok && msg.From == from
|
|
}
|
|
assertion := func(t *testing.T, msg p2p.Envelope) bool {
|
|
m, ok := msg.Message.(*p2pproto.PexResponseV2)
|
|
if !ok {
|
|
require.Fail(t, "expected pex response v2")
|
|
return true
|
|
}
|
|
// assert the same amount of addresses
|
|
if len(m.Addresses) == addresses {
|
|
return true
|
|
}
|
|
// if we didn't get the right length, we wait and send the
|
|
// request again
|
|
time.Sleep(300 * time.Millisecond)
|
|
r.sendRequest(t, toNode, fromNode, true)
|
|
return false
|
|
}
|
|
r.sendRequest(t, toNode, fromNode, true)
|
|
r.listenFor(t, to, conditional, assertion, waitPeriod)
|
|
}
|
|
|
|
func (r *reactorTestSuite) listenForResponse(
|
|
t *testing.T,
|
|
fromNode, toNode int,
|
|
waitPeriod time.Duration,
|
|
addresses []p2pproto.PexAddressV2,
|
|
) {
|
|
r.logger.Info("Listening for response", "from", fromNode, "to", toNode)
|
|
to, from := r.checkNodePair(t, toNode, fromNode)
|
|
conditional := func(msg p2p.Envelope) bool {
|
|
_, ok := msg.Message.(*p2pproto.PexResponseV2)
|
|
r.logger.Info("message", msg, "ok", ok)
|
|
return ok && msg.From == from
|
|
}
|
|
assertion := func(t *testing.T, msg p2p.Envelope) bool {
|
|
require.Equal(t, &p2pproto.PexResponseV2{Addresses: addresses}, msg.Message)
|
|
return true
|
|
}
|
|
r.listenFor(t, to, conditional, assertion, waitPeriod)
|
|
}
|
|
|
|
func (r *reactorTestSuite) listenForLegacyResponse(
|
|
t *testing.T,
|
|
fromNode, toNode int,
|
|
waitPeriod time.Duration,
|
|
addresses []p2pproto.PexAddress,
|
|
) {
|
|
r.logger.Info("Listening for response", "from", fromNode, "to", toNode)
|
|
to, from := r.checkNodePair(t, toNode, fromNode)
|
|
conditional := func(msg p2p.Envelope) bool {
|
|
_, ok := msg.Message.(*p2pproto.PexResponse)
|
|
return ok && msg.From == from
|
|
}
|
|
assertion := func(t *testing.T, msg p2p.Envelope) bool {
|
|
require.Equal(t, &p2pproto.PexResponse{Addresses: addresses}, msg.Message)
|
|
return true
|
|
}
|
|
r.listenFor(t, to, conditional, assertion, waitPeriod)
|
|
}
|
|
|
|
func (r *reactorTestSuite) listenForPeerUpdate(
|
|
t *testing.T,
|
|
onNode, withNode int,
|
|
status p2p.PeerStatus,
|
|
waitPeriod time.Duration,
|
|
) {
|
|
on, with := r.checkNodePair(t, onNode, withNode)
|
|
sub := r.network.Nodes[on].PeerManager.Subscribe()
|
|
defer sub.Close()
|
|
timesUp := time.After(waitPeriod)
|
|
for {
|
|
select {
|
|
case peerUpdate := <-sub.Updates():
|
|
if peerUpdate.NodeID == with {
|
|
require.Equal(t, status, peerUpdate.Status)
|
|
return
|
|
}
|
|
|
|
case <-timesUp:
|
|
require.Fail(t, "timed out waiting for peer status", "%v with status %v",
|
|
with, status)
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
func (r *reactorTestSuite) getV2AddressesFor(nodes []int) []p2pproto.PexAddressV2 {
|
|
addresses := make([]p2pproto.PexAddressV2, len(nodes))
|
|
for idx, node := range nodes {
|
|
nodeID := r.nodes[node]
|
|
addresses[idx] = p2pproto.PexAddressV2{
|
|
URL: r.network.Nodes[nodeID].NodeAddress.String(),
|
|
}
|
|
}
|
|
return addresses
|
|
}
|
|
|
|
func (r *reactorTestSuite) getAddressesFor(t *testing.T, nodes []int) []p2pproto.PexAddress {
|
|
addresses := make([]p2pproto.PexAddress, len(nodes))
|
|
for idx, node := range nodes {
|
|
nodeID := r.nodes[node]
|
|
nodeAddrs := r.network.Nodes[nodeID].NodeAddress
|
|
endpoints, err := nodeAddrs.Resolve(context.Background())
|
|
require.NoError(t, err)
|
|
require.Len(t, endpoints, 1)
|
|
addresses[idx] = p2pproto.PexAddress{
|
|
ID: string(nodeAddrs.NodeID),
|
|
IP: endpoints[0].IP.String(),
|
|
Port: uint32(endpoints[0].Port),
|
|
}
|
|
}
|
|
return addresses
|
|
}
|
|
|
|
func (r *reactorTestSuite) sendRequest(t *testing.T, fromNode, toNode int, v2 bool) {
|
|
to, from := r.checkNodePair(t, toNode, fromNode)
|
|
if v2 {
|
|
r.pexChannels[from].Out <- p2p.Envelope{
|
|
To: to,
|
|
Message: &p2pproto.PexRequestV2{},
|
|
}
|
|
} else {
|
|
r.pexChannels[from].Out <- p2p.Envelope{
|
|
To: to,
|
|
Message: &p2pproto.PexRequest{},
|
|
}
|
|
}
|
|
}
|
|
|
|
func (r *reactorTestSuite) sendResponse(
|
|
t *testing.T,
|
|
fromNode, toNode int,
|
|
withNodes []int,
|
|
v2 bool,
|
|
) {
|
|
from, to := r.checkNodePair(t, fromNode, toNode)
|
|
if v2 {
|
|
addrs := r.getV2AddressesFor(withNodes)
|
|
r.pexChannels[from].Out <- p2p.Envelope{
|
|
To: to,
|
|
Message: &p2pproto.PexResponseV2{
|
|
Addresses: addrs,
|
|
},
|
|
}
|
|
} else {
|
|
addrs := r.getAddressesFor(t, withNodes)
|
|
r.pexChannels[from].Out <- p2p.Envelope{
|
|
To: to,
|
|
Message: &p2pproto.PexResponse{
|
|
Addresses: addrs,
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
func (r *reactorTestSuite) requireNumberOfPeers(
|
|
t *testing.T,
|
|
nodeIndex, numPeers int,
|
|
waitPeriod time.Duration,
|
|
) {
|
|
t.Helper()
|
|
require.Eventuallyf(t, func() bool {
|
|
actualNumPeers := len(r.network.Nodes[r.nodes[nodeIndex]].PeerManager.Peers())
|
|
return actualNumPeers >= numPeers
|
|
}, waitPeriod, checkFrequency, "peer failed to connect with the asserted amount of peers "+
|
|
"index=%d, node=%q, waitPeriod=%s expected=%d actual=%d",
|
|
nodeIndex, r.nodes[nodeIndex], waitPeriod, numPeers,
|
|
len(r.network.Nodes[r.nodes[nodeIndex]].PeerManager.Peers()),
|
|
)
|
|
}
|
|
|
|
func (r *reactorTestSuite) connectAll(t *testing.T) {
|
|
r.connectN(t, r.total-1)
|
|
}
|
|
|
|
// connects all nodes with n other nodes
|
|
func (r *reactorTestSuite) connectN(t *testing.T, n int) {
|
|
if n >= r.total {
|
|
require.Fail(t, "connectN: n must be less than the size of the network - 1")
|
|
}
|
|
|
|
for i := 0; i < r.total; i++ {
|
|
for j := 0; j < n; j++ {
|
|
r.connectPeers(t, i, (i+j+1)%r.total)
|
|
}
|
|
}
|
|
}
|
|
|
|
// connects node1 to node2
|
|
func (r *reactorTestSuite) connectPeers(t *testing.T, sourceNode, targetNode int) {
|
|
t.Helper()
|
|
node1, node2 := r.checkNodePair(t, sourceNode, targetNode)
|
|
r.logger.Info("connecting peers", "sourceNode", sourceNode, "targetNode", targetNode)
|
|
|
|
n1 := r.network.Nodes[node1]
|
|
if n1 == nil {
|
|
require.Fail(t, "connectPeers: source node %v is not part of the testnet", node1)
|
|
return
|
|
}
|
|
|
|
n2 := r.network.Nodes[node2]
|
|
if n2 == nil {
|
|
require.Fail(t, "connectPeers: target node %v is not part of the testnet", node2)
|
|
return
|
|
}
|
|
|
|
sourceSub := n1.PeerManager.Subscribe()
|
|
defer sourceSub.Close()
|
|
targetSub := n2.PeerManager.Subscribe()
|
|
defer targetSub.Close()
|
|
|
|
sourceAddress := n1.NodeAddress
|
|
r.logger.Debug("source address", "address", sourceAddress)
|
|
targetAddress := n2.NodeAddress
|
|
r.logger.Debug("target address", "address", targetAddress)
|
|
|
|
added, err := n1.PeerManager.Add(targetAddress)
|
|
require.NoError(t, err)
|
|
|
|
if !added {
|
|
r.logger.Debug("nodes already know about one another",
|
|
"sourceNode", sourceNode, "targetNode", targetNode)
|
|
return
|
|
}
|
|
|
|
select {
|
|
case peerUpdate := <-targetSub.Updates():
|
|
require.Equal(t, p2p.PeerUpdate{
|
|
NodeID: node1,
|
|
Status: p2p.PeerStatusUp,
|
|
}, peerUpdate)
|
|
r.logger.Debug("target connected with source")
|
|
case <-time.After(2 * time.Second):
|
|
require.Fail(t, "timed out waiting for peer", "%v accepting %v",
|
|
targetNode, sourceNode)
|
|
}
|
|
|
|
select {
|
|
case peerUpdate := <-sourceSub.Updates():
|
|
require.Equal(t, p2p.PeerUpdate{
|
|
NodeID: node2,
|
|
Status: p2p.PeerStatusUp,
|
|
}, peerUpdate)
|
|
r.logger.Debug("source connected with target")
|
|
case <-time.After(2 * time.Second):
|
|
require.Fail(t, "timed out waiting for peer", "%v dialing %v",
|
|
sourceNode, targetNode)
|
|
}
|
|
|
|
added, err = n2.PeerManager.Add(sourceAddress)
|
|
require.NoError(t, err)
|
|
require.True(t, added)
|
|
}
|
|
|
|
// nolint: unused
|
|
func (r *reactorTestSuite) pexAddresses(t *testing.T, nodeIndices []int) []p2pproto.PexAddress {
|
|
var addresses []p2pproto.PexAddress
|
|
for _, i := range nodeIndices {
|
|
if i < len(r.nodes) {
|
|
require.Fail(t, "index for pex address is greater than number of nodes")
|
|
}
|
|
nodeAddrs := r.network.Nodes[r.nodes[i]].NodeAddress
|
|
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
|
|
endpoints, err := nodeAddrs.Resolve(ctx)
|
|
cancel()
|
|
require.NoError(t, err)
|
|
for _, endpoint := range endpoints {
|
|
if endpoint.IP != nil {
|
|
addresses = append(addresses, p2pproto.PexAddress{
|
|
ID: string(nodeAddrs.NodeID),
|
|
IP: endpoint.IP.String(),
|
|
Port: uint32(endpoint.Port),
|
|
})
|
|
}
|
|
}
|
|
|
|
}
|
|
return addresses
|
|
}
|
|
|
|
func (r *reactorTestSuite) checkNodePair(t *testing.T, first, second int) (types.NodeID, types.NodeID) {
|
|
require.NotEqual(t, first, second)
|
|
require.Less(t, first, r.total)
|
|
require.Less(t, second, r.total)
|
|
return r.nodes[first], r.nodes[second]
|
|
}
|
|
|
|
func (r *reactorTestSuite) addAddresses(t *testing.T, node int, addrs []int) {
|
|
peerManager := r.network.Nodes[r.nodes[node]].PeerManager
|
|
for _, addr := range addrs {
|
|
require.Less(t, addr, r.total)
|
|
address := r.network.Nodes[r.nodes[addr]].NodeAddress
|
|
added, err := peerManager.Add(address)
|
|
require.NoError(t, err)
|
|
require.True(t, added)
|
|
}
|
|
}
|
|
|
|
func newNodeID(t *testing.T, id string) types.NodeID {
|
|
nodeID, err := types.NewNodeID(strings.Repeat(id, 2*types.NodeIDByteLength))
|
|
require.NoError(t, err)
|
|
return nodeID
|
|
}
|
|
|
|
func randomNodeID(t *testing.T) types.NodeID {
|
|
return types.NodeIDFromPubKey(ed25519.GenPrivKey().PubKey())
|
|
}
|