9 cfg "github.com/bytom/bytom/config"
10 "github.com/bytom/bytom/crypto/ed25519/chainkd"
11 conn "github.com/bytom/bytom/p2p/connection"
12 "github.com/bytom/bytom/version"
17 func TestPeerBasic(t *testing.T) {
18 // simulate remote peer
19 xPrv, _ := chainkd.NewXPrv(nil)
20 rp := &remotePeer{PrivKey: xPrv, Config: testCfg}
24 p, err := createOutboundPeerAndPerformHandshake(rp.Addr(), cfg.DefaultP2PConfig())
29 if err = p.Start(); err != nil {
35 func TestPeerSend(t *testing.T) {
38 xPrv, _ := chainkd.NewXPrv(nil)
39 // simulate remote peer
40 rp := &remotePeer{PrivKey: xPrv, Config: config}
44 p, err := createOutboundPeerAndPerformHandshake(rp.Addr(), config.P2P)
49 if err = p.Start(); err != nil {
54 if ok := p.CanSend(testCh); !ok {
55 t.Fatal("TestPeerSend send err")
58 if ok := p.TrySend(testCh, []byte("test date")); !ok {
59 t.Fatal("TestPeerSend try send err")
63 func createOutboundPeerAndPerformHandshake(
65 config *cfg.P2PConfig,
67 chDescs := []*conn.ChannelDescriptor{
68 {ID: testCh, Priority: 1},
70 reactorsByCh := map[byte]Reactor{testCh: NewTestReactor(chDescs, true)}
71 privkey, _ := chainkd.NewXPrv(nil)
72 peerConfig := DefaultPeerConfig(config)
73 pc, err := newOutboundPeerConn(addr, privkey, peerConfig)
77 nodeInfo, err := pc.HandshakeTimeout(&NodeInfo{
80 Version: "123.123.123",
86 p := newPeer(pc, nodeInfo, reactorsByCh, chDescs, nil, false)
90 type remotePeer struct {
98 func (rp *remotePeer) Addr() *NetAddress {
102 func (rp *remotePeer) Start() {
103 if rp.listenAddr == "" {
104 rp.listenAddr = "127.0.0.1:0"
107 l, e := net.Listen("tcp", rp.listenAddr) // any available address
109 fmt.Println("net.Listen tcp :0:", e)
111 rp.addr = NewNetAddress(l.Addr())
112 rp.quit = make(chan struct{})
116 func (rp *remotePeer) Stop() {
120 func (rp *remotePeer) accept(l net.Listener) {
121 conns := []net.Conn{}
124 conn, err := l.Accept()
126 fmt.Println("Failed to accept conn:", err)
129 pc, err := newInboundPeerConn(conn, rp.PrivKey, rp.Config.P2P)
131 fmt.Println("Failed to create a peer:", err)
134 _, err = pc.HandshakeTimeout(&NodeInfo{
135 PubKey: rp.PrivKey.XPub().PublicKey(),
136 Moniker: "remote_peer",
137 Network: rp.Config.ChainID,
138 Version: version.Version,
139 ListenAddr: l.Addr().String(),
142 fmt.Println("Failed to perform handshake:", err)
144 conns = append(conns, conn)
147 for _, conn := range conns {
148 if err := conn.Close(); err != nil {
158 type inboundPeer struct {
163 func (ip *inboundPeer) dial(addr *NetAddress) {
164 pc, err := newOutboundPeerConn(addr, ip.PrivKey, DefaultPeerConfig(ip.config.P2P))
166 fmt.Println("newOutboundPeerConn:", err)
170 _, err = pc.HandshakeTimeout(&NodeInfo{
171 PubKey: ip.PrivKey.XPub().PublicKey(),
172 Moniker: "remote_peer",
173 Network: ip.config.ChainID,
174 Version: version.Version,
175 ListenAddr: addr.String(),
178 fmt.Println("Failed to perform handshake:", err)
181 time.AfterFunc(10*time.Second, pc.CloseConn)