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.
148 lines
3.8 KiB
148 lines
3.8 KiB
package p2p
|
|
|
|
import (
|
|
"math/rand"
|
|
"net"
|
|
|
|
crypto "github.com/tendermint/go-crypto"
|
|
cmn "github.com/tendermint/tmlibs/common"
|
|
"github.com/tendermint/tmlibs/log"
|
|
|
|
cfg "github.com/tendermint/tendermint/config"
|
|
"github.com/tendermint/tendermint/p2p/tmconn"
|
|
"github.com/tendermint/tendermint/p2p/types"
|
|
)
|
|
|
|
func AddPeerToSwitch(sw *Switch, peer Peer) {
|
|
sw.peers.Add(peer)
|
|
}
|
|
|
|
func CreateRandomPeer(outbound bool) *peer {
|
|
addr, netAddr := CreateRoutableAddr()
|
|
p := &peer{
|
|
nodeInfo: types.NodeInfo{
|
|
ListenAddr: netAddr.DialString(),
|
|
PubKey: crypto.GenPrivKeyEd25519().Wrap().PubKey(),
|
|
},
|
|
outbound: outbound,
|
|
mconn: &tmconn.MConnection{},
|
|
}
|
|
p.SetLogger(log.TestingLogger().With("peer", addr))
|
|
return p
|
|
}
|
|
|
|
func CreateRoutableAddr() (addr string, netAddr *types.NetAddress) {
|
|
for {
|
|
var err error
|
|
addr = cmn.Fmt("%X@%v.%v.%v.%v:46656", cmn.RandBytes(20), rand.Int()%256, rand.Int()%256, rand.Int()%256, rand.Int()%256)
|
|
netAddr, err = types.NewNetAddressString(addr)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
if netAddr.Routable() {
|
|
break
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
// Connects switches via arbitrary net.Conn. Used for testing.
|
|
|
|
// MakeConnectedSwitches returns n switches, connected according to the connect func.
|
|
// If connect==Connect2Switches, the switches will be fully connected.
|
|
// initSwitch defines how the i'th switch should be initialized (ie. with what reactors).
|
|
// NOTE: panics if any switch fails to start.
|
|
func MakeConnectedSwitches(cfg *cfg.P2PConfig, n int, initSwitch func(int, *Switch) *Switch, connect func([]*Switch, int, int)) []*Switch {
|
|
switches := make([]*Switch, n)
|
|
for i := 0; i < n; i++ {
|
|
switches[i] = MakeSwitch(cfg, i, "testing", "123.123.123", initSwitch)
|
|
}
|
|
|
|
if err := StartSwitches(switches); err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
for i := 0; i < n; i++ {
|
|
for j := i + 1; j < n; j++ {
|
|
connect(switches, i, j)
|
|
}
|
|
}
|
|
|
|
return switches
|
|
}
|
|
|
|
// Connect2Switches will connect switches i and j via net.Pipe().
|
|
// Blocks until a connection is established.
|
|
// NOTE: caller ensures i and j are within bounds.
|
|
func Connect2Switches(switches []*Switch, i, j int) {
|
|
switchI := switches[i]
|
|
switchJ := switches[j]
|
|
c1, c2 := tmconn.NetPipe()
|
|
doneCh := make(chan struct{})
|
|
go func() {
|
|
err := switchI.addPeerWithConnection(c1)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
doneCh <- struct{}{}
|
|
}()
|
|
go func() {
|
|
err := switchJ.addPeerWithConnection(c2)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
doneCh <- struct{}{}
|
|
}()
|
|
<-doneCh
|
|
<-doneCh
|
|
}
|
|
|
|
func (sw *Switch) addPeerWithConnection(conn net.Conn) error {
|
|
peer, err := newInboundPeer(conn, sw.reactorsByCh, sw.chDescs, sw.StopPeerForError, sw.nodeKey.PrivKey, sw.peerConfig)
|
|
if err != nil {
|
|
if err := conn.Close(); err != nil {
|
|
sw.Logger.Error("Error closing connection", "err", err)
|
|
}
|
|
return err
|
|
}
|
|
peer.SetLogger(sw.Logger.With("peer", conn.RemoteAddr()))
|
|
if err = sw.addPeer(peer); err != nil {
|
|
peer.CloseConn()
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// StartSwitches calls sw.Start() for each given switch.
|
|
// It returns the first encountered error.
|
|
func StartSwitches(switches []*Switch) error {
|
|
for _, s := range switches {
|
|
err := s.Start() // start switch and reactors
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func MakeSwitch(cfg *cfg.P2PConfig, i int, network, version string, initSwitch func(int, *Switch) *Switch) *Switch {
|
|
// new switch, add reactors
|
|
// TODO: let the config be passed in?
|
|
nodeKey := &types.NodeKey{
|
|
PrivKey: crypto.GenPrivKeyEd25519().Wrap(),
|
|
}
|
|
s := NewSwitch(cfg)
|
|
s.SetLogger(log.TestingLogger())
|
|
s = initSwitch(i, s)
|
|
s.SetNodeInfo(types.NodeInfo{
|
|
PubKey: nodeKey.PubKey(),
|
|
Moniker: cmn.Fmt("switch%d", i),
|
|
Network: network,
|
|
Version: version,
|
|
ListenAddr: cmn.Fmt("%v:%v", network, rand.Intn(64512)+1023),
|
|
})
|
|
s.SetNodeKey(nodeKey)
|
|
return s
|
|
}
|