package p2p
import (
+ "fmt"
"net"
"testing"
"time"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/tendermint/go-crypto"
- log "github.com/sirupsen/logrus"
- crypto "github.com/tendermint/go-crypto"
+ cfg "github.com/bytom/bytom/config"
+ conn "github.com/bytom/bytom/p2p/connection"
+ "github.com/bytom/bytom/version"
)
-func TestPeerBasic(t *testing.T) {
- assert, require := assert.New(t), require.New(t)
-
- // simulate remote peer
- rp := &remotePeer{PrivKey: crypto.GenPrivKeyEd25519(), Config: DefaultPeerConfig()}
- rp.Start()
- defer rp.Stop()
-
- p, err := createOutboundPeerAndPerformHandshake(rp.Addr(), DefaultPeerConfig())
- require.Nil(err)
-
- p.Start()
- defer p.Stop()
-
- assert.True(p.IsRunning())
- assert.True(p.IsOutbound())
- assert.False(p.IsPersistent())
- p.makePersistent()
- assert.True(p.IsPersistent())
- assert.Equal(rp.Addr().String(), p.Addr().String())
- assert.Equal(rp.PubKey(), p.PubKey())
-}
-
-func TestPeerWithoutAuthEnc(t *testing.T) {
- assert, require := assert.New(t), require.New(t)
-
- config := DefaultPeerConfig()
- config.AuthEnc = false
+const testCh = 0x01
+func TestPeerBasic(t *testing.T) {
// simulate remote peer
- rp := &remotePeer{PrivKey: crypto.GenPrivKeyEd25519(), Config: config}
+ rp := &remotePeer{PrivKey: crypto.GenPrivKeyEd25519(), Config: testCfg}
rp.Start()
defer rp.Stop()
- p, err := createOutboundPeerAndPerformHandshake(rp.Addr(), config)
- require.Nil(err)
-
- p.Start()
+ p, err := createOutboundPeerAndPerformHandshake(rp.Addr(), cfg.DefaultP2PConfig())
+ if err != nil {
+ t.Fatal(err)
+ }
+ _, err = p.Start()
+ if err != nil {
+ t.Fatal(err)
+ }
defer p.Stop()
-
- assert.True(p.IsRunning())
}
func TestPeerSend(t *testing.T) {
- assert, require := assert.New(t), require.New(t)
-
- config := DefaultPeerConfig()
- config.AuthEnc = false
+ config := testCfg
// simulate remote peer
rp := &remotePeer{PrivKey: crypto.GenPrivKeyEd25519(), Config: config}
rp.Start()
defer rp.Stop()
- p, err := createOutboundPeerAndPerformHandshake(rp.Addr(), config)
- require.Nil(err)
+ p, err := createOutboundPeerAndPerformHandshake(rp.Addr(), config.P2P)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ _, err = p.Start()
+ if err != nil {
+ t.Fatal(err)
+ }
- p.Start()
defer p.Stop()
+ if ok := p.CanSend(testCh); !ok {
+ t.Fatal("TestPeerSend send err")
+ }
- assert.True(p.CanSend(0x01))
- assert.True(p.Send(0x01, "Asylum"))
+ if ok := p.TrySend(testCh, []byte("test date")); !ok {
+ t.Fatal("TestPeerSend try send err")
+ }
}
-func createOutboundPeerAndPerformHandshake(addr *NetAddress, config *PeerConfig) (*Peer, error) {
- chDescs := []*ChannelDescriptor{
- &ChannelDescriptor{ID: 0x01, Priority: 1},
+func createOutboundPeerAndPerformHandshake(
+ addr *NetAddress,
+ config *cfg.P2PConfig,
+) (*Peer, error) {
+ chDescs := []*conn.ChannelDescriptor{
+ {ID: testCh, Priority: 1},
}
- reactorsByCh := map[byte]Reactor{0x01: NewTestReactor(chDescs, true)}
- pk := crypto.GenPrivKeyEd25519()
- p, err := newOutboundPeerWithConfig(addr, reactorsByCh, chDescs, func(p *Peer, r interface{}) {}, pk, config)
+ reactorsByCh := map[byte]Reactor{testCh: NewTestReactor(chDescs, true)}
+ privkey := crypto.GenPrivKeyEd25519()
+ peerConfig := DefaultPeerConfig(config)
+ pc, err := newOutboundPeerConn(addr, privkey, peerConfig)
if err != nil {
return nil, err
}
- err = p.HandshakeTimeout(&NodeInfo{
- PubKey: pk.PubKey().Unwrap().(crypto.PubKeyEd25519),
+ nodeInfo, err := pc.HandshakeTimeout(&NodeInfo{
Moniker: "host_peer",
Network: "testing",
Version: "123.123.123",
- }, 1*time.Second)
+ }, 5*time.Second)
if err != nil {
+ fmt.Println(err)
return nil, err
}
+ p := newPeer(pc, nodeInfo, reactorsByCh, chDescs, nil, false)
return p, nil
}
type remotePeer struct {
- PrivKey crypto.PrivKeyEd25519
- Config *PeerConfig
- addr *NetAddress
- quit chan struct{}
+ PrivKey crypto.PrivKeyEd25519
+ Config *cfg.Config
+ addr *NetAddress
+ quit chan struct{}
+ listenAddr string
}
-func (p *remotePeer) Addr() *NetAddress {
- return p.addr
+func (rp *remotePeer) Addr() *NetAddress {
+ return rp.addr
}
-func (p *remotePeer) PubKey() crypto.PubKeyEd25519 {
- return p.PrivKey.PubKey().Unwrap().(crypto.PubKeyEd25519)
-}
+func (rp *remotePeer) Start() {
+ if rp.listenAddr == "" {
+ rp.listenAddr = "127.0.0.1:0"
+ }
-func (p *remotePeer) Start() {
- l, e := net.Listen("tcp", "127.0.0.1:0") // any available address
+ l, e := net.Listen("tcp", rp.listenAddr) // any available address
if e != nil {
- log.Fatalf("net.Listen tcp :0: %+v", e)
+ fmt.Println("net.Listen tcp :0:", e)
}
- p.addr = NewNetAddress(l.Addr())
- p.quit = make(chan struct{})
- go p.accept(l)
+ rp.addr = NewNetAddress(l.Addr())
+ rp.quit = make(chan struct{})
+ go rp.accept(l)
}
-func (p *remotePeer) Stop() {
- close(p.quit)
+func (rp *remotePeer) Stop() {
+ close(rp.quit)
}
-func (p *remotePeer) accept(l net.Listener) {
+func (rp *remotePeer) accept(l net.Listener) {
+ conns := []net.Conn{}
+
for {
conn, err := l.Accept()
if err != nil {
- log.Fatalf("Failed to accept conn: %+v", err)
+ fmt.Println("Failed to accept conn:", err)
}
- peer, err := newInboundPeerWithConfig(conn, make(map[byte]Reactor), make([]*ChannelDescriptor, 0), func(p *Peer, r interface{}) {}, p.PrivKey, p.Config)
+
+ pc, err := newInboundPeerConn(conn, rp.PrivKey, rp.Config.P2P)
if err != nil {
- log.Fatalf("Failed to create a peer: %+v", err)
+ fmt.Println("Failed to create a peer:", err)
}
- err = peer.HandshakeTimeout(&NodeInfo{
- PubKey: p.PrivKey.PubKey().Unwrap().(crypto.PubKeyEd25519),
- Moniker: "remote_peer",
- Network: "testing",
- Version: "123.123.123",
- }, 1*time.Second)
+
+ _, err = pc.HandshakeTimeout(&NodeInfo{
+ PubKey: rp.PrivKey.PubKey().Unwrap().(crypto.PubKeyEd25519),
+ Moniker: "remote_peer",
+ Network: rp.Config.ChainID,
+ Version: version.Version,
+ ListenAddr: l.Addr().String(),
+ }, 5*time.Second)
if err != nil {
- log.Fatalf("Failed to perform handshake: %+v", err)
+ fmt.Println("Failed to perform handshake:", err)
}
+ conns = append(conns, conn)
select {
- case <-p.quit:
- conn.Close()
+ case <-rp.quit:
+ for _, conn := range conns {
+ if err := conn.Close(); err != nil {
+ fmt.Println(err)
+ }
+ }
return
default:
}
}
}
+
+type inboundPeer struct {
+ PrivKey crypto.PrivKeyEd25519
+ config *cfg.Config
+}
+
+func (ip *inboundPeer) dial(addr *NetAddress) {
+ pc, err := newOutboundPeerConn(addr, ip.PrivKey, DefaultPeerConfig(ip.config.P2P))
+ if err != nil {
+ fmt.Println("newOutboundPeerConn:", err)
+ return
+ }
+
+ _, err = pc.HandshakeTimeout(&NodeInfo{
+ PubKey: ip.PrivKey.PubKey().Unwrap().(crypto.PubKeyEd25519),
+ Moniker: "remote_peer",
+ Network: ip.config.ChainID,
+ Version: version.Version,
+ ListenAddr: addr.String(),
+ }, 5*time.Second)
+ if err != nil {
+ fmt.Println("Failed to perform handshake:", err)
+ return
+ }
+ time.AfterFunc(10*time.Second, pc.CloseConn)
+}
OSDN Git Service
