From 75e779fb294b8fa4bf1f547b04662810258a66ec Mon Sep 17 00:00:00 2001 From: Yuttakhan Baingen Date: Wed, 29 Jan 2025 16:55:18 +0700 Subject: [PATCH 1/4] test: add host with circuitv2 to integration test --- p2p/test/transport/transport_test.go | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/p2p/test/transport/transport_test.go b/p2p/test/transport/transport_test.go index 60f8ca0c06..84e3f1dfdb 100644 --- a/p2p/test/transport/transport_test.go +++ b/p2p/test/transport/transport_test.go @@ -188,6 +188,22 @@ var transportsToTest = []TransportTestCase{ return h }, }, + { + Name: "Circuit V2", + HostGenerator: func(t *testing.T, opts TransportTestCaseOpts) host.Host { + libp2pOpts := transformOpts(opts) + libp2pOpts = append(libp2pOpts, libp2p.EnableRelay()) + libp2pOpts = append(libp2pOpts, libp2p.EnableRelayService()) + if opts.NoListen { + libp2pOpts = append(libp2pOpts, libp2p.NoListenAddrs) + } else { + libp2pOpts = append(libp2pOpts, libp2p.ListenAddrStrings(("/ip4/127.0.0.1/tcp/0/ws"))) + } + h, err := libp2p.New(libp2pOpts...) + require.NoError(t, err) + return h + }, + }, } func TestPing(t *testing.T) { From a2089566307cd536405354a38970d7cc871e5a22 Mon Sep 17 00:00:00 2001 From: Yuttakhan Baingen Date: Wed, 5 Feb 2025 17:58:04 +0700 Subject: [PATCH 2/4] test: update HostGenerator with enabling relay, add testing relay connection --- p2p/test/transport/transport_test.go | 171 ++++++++++++++++++++++++--- 1 file changed, 156 insertions(+), 15 deletions(-) diff --git a/p2p/test/transport/transport_test.go b/p2p/test/transport/transport_test.go index 84e3f1dfdb..dde6d07c6c 100644 --- a/p2p/test/transport/transport_test.go +++ b/p2p/test/transport/transport_test.go @@ -28,6 +28,8 @@ import ( rcmgr "github.com/libp2p/go-libp2p/p2p/host/resource-manager" "github.com/libp2p/go-libp2p/p2p/muxer/yamux" "github.com/libp2p/go-libp2p/p2p/net/swarm" + "github.com/libp2p/go-libp2p/p2p/protocol/circuitv2/client" + "github.com/libp2p/go-libp2p/p2p/protocol/circuitv2/relay" "github.com/libp2p/go-libp2p/p2p/protocol/ping" "github.com/libp2p/go-libp2p/p2p/security/noise" tls "github.com/libp2p/go-libp2p/p2p/security/tls" @@ -46,6 +48,7 @@ type TransportTestCase struct { type TransportTestCaseOpts struct { NoListen bool NoRcmgr bool + EnabledRelay bool ConnGater connmgr.ConnectionGater ResourceManager network.ResourceManager } @@ -66,6 +69,14 @@ func transformOpts(opts TransportTestCaseOpts) []config.Option { return libp2pOpts } +func connect(t *testing.T, a, b host.Host) { + pi := peer.AddrInfo{ID: a.ID(), Addrs: a.Addrs()} + err := b.Connect(context.Background(), pi) + if err != nil { + t.Fatal(err) + } +} + var transportsToTest = []TransportTestCase{ { Name: "TCP / Noise / Yamux", @@ -78,6 +89,9 @@ var transportsToTest = []TransportTestCase{ } else { libp2pOpts = append(libp2pOpts, libp2p.ListenAddrStrings("/ip4/127.0.0.1/tcp/0")) } + if opts.EnabledRelay { + libp2pOpts = append(libp2pOpts, libp2p.EnableRelay(), libp2p.EnableRelayService()) + } h, err := libp2p.New(libp2pOpts...) require.NoError(t, err) return h @@ -94,6 +108,9 @@ var transportsToTest = []TransportTestCase{ } else { libp2pOpts = append(libp2pOpts, libp2p.ListenAddrStrings("/ip4/127.0.0.1/tcp/0")) } + if opts.EnabledRelay { + libp2pOpts = append(libp2pOpts, libp2p.EnableRelay(), libp2p.EnableRelayService()) + } h, err := libp2p.New(libp2pOpts...) require.NoError(t, err) return h @@ -111,6 +128,9 @@ var transportsToTest = []TransportTestCase{ } else { libp2pOpts = append(libp2pOpts, libp2p.ListenAddrStrings("/ip4/127.0.0.1/tcp/0")) } + if opts.EnabledRelay { + libp2pOpts = append(libp2pOpts, libp2p.EnableRelay(), libp2p.EnableRelayService()) + } h, err := libp2p.New(libp2pOpts...) require.NoError(t, err) return h @@ -126,6 +146,9 @@ var transportsToTest = []TransportTestCase{ } else { libp2pOpts = append(libp2pOpts, libp2p.ListenAddrStrings("/ip4/127.0.0.1/tcp/0/ws")) } + if opts.EnabledRelay { + libp2pOpts = append(libp2pOpts, libp2p.EnableRelay(), libp2p.EnableRelayService()) + } h, err := libp2p.New(libp2pOpts...) require.NoError(t, err) return h @@ -140,6 +163,9 @@ var transportsToTest = []TransportTestCase{ } else { libp2pOpts = append(libp2pOpts, libp2p.ListenAddrStrings("/ip4/127.0.0.1/tcp/0/ws")) } + if opts.EnabledRelay { + libp2pOpts = append(libp2pOpts, libp2p.EnableRelay(), libp2p.EnableRelayService()) + } h, err := libp2p.New(libp2pOpts...) require.NoError(t, err) return h @@ -154,6 +180,9 @@ var transportsToTest = []TransportTestCase{ } else { libp2pOpts = append(libp2pOpts, libp2p.ListenAddrStrings("/ip4/127.0.0.1/udp/0/quic-v1")) } + if opts.EnabledRelay { + libp2pOpts = append(libp2pOpts, libp2p.EnableRelay(), libp2p.EnableRelayService()) + } h, err := libp2p.New(libp2pOpts...) require.NoError(t, err) return h @@ -168,6 +197,9 @@ var transportsToTest = []TransportTestCase{ } else { libp2pOpts = append(libp2pOpts, libp2p.ListenAddrStrings("/ip4/127.0.0.1/udp/0/quic-v1/webtransport")) } + if opts.EnabledRelay { + libp2pOpts = append(libp2pOpts, libp2p.EnableRelay(), libp2p.EnableRelayService()) + } h, err := libp2p.New(libp2pOpts...) require.NoError(t, err) return h @@ -183,21 +215,8 @@ var transportsToTest = []TransportTestCase{ } else { libp2pOpts = append(libp2pOpts, libp2p.ListenAddrStrings("/ip4/127.0.0.1/udp/0/webrtc-direct")) } - h, err := libp2p.New(libp2pOpts...) - require.NoError(t, err) - return h - }, - }, - { - Name: "Circuit V2", - HostGenerator: func(t *testing.T, opts TransportTestCaseOpts) host.Host { - libp2pOpts := transformOpts(opts) - libp2pOpts = append(libp2pOpts, libp2p.EnableRelay()) - libp2pOpts = append(libp2pOpts, libp2p.EnableRelayService()) - if opts.NoListen { - libp2pOpts = append(libp2pOpts, libp2p.NoListenAddrs) - } else { - libp2pOpts = append(libp2pOpts, libp2p.ListenAddrStrings(("/ip4/127.0.0.1/tcp/0/ws"))) + if opts.EnabledRelay { + libp2pOpts = append(libp2pOpts, libp2p.EnableRelay(), libp2p.EnableRelayService()) } h, err := libp2p.New(libp2pOpts...) require.NoError(t, err) @@ -846,3 +865,125 @@ func TestConnClosedWhenRemoteCloses(t *testing.T) { }) } } + +func TestConnRelay(t *testing.T) { + for _, tc := range transportsToTest { + t.Run(tc.Name, func(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + + var hosts []host.Host + // Set host + for i := 0; i < 3; i++ { + h := tc.HostGenerator(t, TransportTestCaseOpts{EnabledRelay: true}) + hosts = append(hosts, h) + } + + // Set stream handler + rch := make(chan []byte, 1) + hosts[0].SetStreamHandler("test", func(s network.Stream) { + defer s.Close() + defer close(rch) + + buf := make([]byte, 1024) + nread := 0 + for nread < len(buf) { + n, err := s.Read(buf[nread:]) + nread += n + if err != nil { + if err == io.EOF { + break + } + t.Fatal(err) + } + } + + rch <- buf[:nread] + }) + + r, err := relay.New(hosts[1]) + if err != nil { + t.Fatal(err) + } + defer r.Close() + + connect(t, hosts[0], hosts[1]) + connect(t, hosts[1], hosts[2]) + + rinfo := hosts[1].Peerstore().PeerInfo(hosts[1].ID()) + rsvp, err := client.Reserve(ctx, hosts[0], rinfo) + if err != nil { + t.Fatal(err) + } + + if rsvp.Voucher == nil { + t.Fatal("no reservation voucher") + } + + raddr, err := ma.NewMultiaddr(fmt.Sprintf("/p2p/%s/p2p-circuit/p2p/%s", hosts[1].ID(), hosts[0].ID())) + if err != nil { + t.Fatal(err) + } + + sub, err := hosts[2].EventBus().Subscribe(new(event.EvtPeerConnectednessChanged)) + require.NoError(t, err) + + err = hosts[2].Connect(ctx, peer.AddrInfo{ID: hosts[0].ID(), Addrs: []ma.Multiaddr{raddr}}) + if err != nil { + t.Fatal(err) + } + for { + var e interface{} + select { + case e = <-sub.Out(): + case <-time.After(2 * time.Second): + t.Fatal("expected limited connectivity event") + } + evt, ok := e.(event.EvtPeerConnectednessChanged) + if !ok { + t.Fatalf("invalid event: %s", e) + } + if evt.Peer == hosts[0].ID() { + if evt.Connectedness != network.Limited { + t.Fatalf("expected limited connectivity %s", evt.Connectedness) + } + break + } + } + + conns := hosts[2].Network().ConnsToPeer(hosts[0].ID()) + if len(conns) != 1 { + t.Fatalf("expected 1 connection, but got %d", len(conns)) + } + if !conns[0].Stat().Limited { + t.Fatal("expected transient connection") + } + + s, err := hosts[2].NewStream(network.WithAllowLimitedConn(ctx, "test"), hosts[0].ID(), "test") + if err != nil { + t.Fatal(err) + } + + msg := []byte("relay works!") + nwritten, err := s.Write(msg) + if err != nil { + t.Fatal(err) + } + if nwritten != len(msg) { + t.Fatalf("expected to write %d bytes, but wrote %d instead", len(msg), nwritten) + } + s.CloseWrite() + + got := <-rch + if !bytes.Equal(msg, got) { + t.Fatalf("Wrong echo; expected %s but got %s", string(msg), string(got)) + } + + t.Cleanup(func() { + for i := range len(hosts) { + hosts[i].Close() + } + }) + }) + } +} From f6364421945fabb8b1479e0b1ae865dc33bbbd2d Mon Sep 17 00:00:00 2001 From: Yuttakhan Baingen Date: Fri, 7 Feb 2025 21:34:29 +0700 Subject: [PATCH 3/4] refactor: add constant flag for transport to test in relay --- p2p/test/transport/transport_test.go | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/p2p/test/transport/transport_test.go b/p2p/test/transport/transport_test.go index dde6d07c6c..67c24a59dd 100644 --- a/p2p/test/transport/transport_test.go +++ b/p2p/test/transport/transport_test.go @@ -77,6 +77,8 @@ func connect(t *testing.T, a, b host.Host) { } } +const RelayTestOnTransportName = "QUIC" + var transportsToTest = []TransportTestCase{ { Name: "TCP / Noise / Yamux", @@ -868,6 +870,10 @@ func TestConnClosedWhenRemoteCloses(t *testing.T) { func TestConnRelay(t *testing.T) { for _, tc := range transportsToTest { + if tc.Name != RelayTestOnTransportName { + continue + } + t.Run(tc.Name, func(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() From 7723e4fcce5316c65f07566e619c73d758f6099a Mon Sep 17 00:00:00 2001 From: Yuttakhan Baingen Date: Tue, 11 Feb 2025 09:18:12 +0700 Subject: [PATCH 4/4] test: add circuitv2 host, remove skipping host --- p2p/test/transport/transport_test.go | 43 +++++++++------------------- 1 file changed, 14 insertions(+), 29 deletions(-) diff --git a/p2p/test/transport/transport_test.go b/p2p/test/transport/transport_test.go index 67c24a59dd..b3b030160b 100644 --- a/p2p/test/transport/transport_test.go +++ b/p2p/test/transport/transport_test.go @@ -48,7 +48,6 @@ type TransportTestCase struct { type TransportTestCaseOpts struct { NoListen bool NoRcmgr bool - EnabledRelay bool ConnGater connmgr.ConnectionGater ResourceManager network.ResourceManager } @@ -91,9 +90,6 @@ var transportsToTest = []TransportTestCase{ } else { libp2pOpts = append(libp2pOpts, libp2p.ListenAddrStrings("/ip4/127.0.0.1/tcp/0")) } - if opts.EnabledRelay { - libp2pOpts = append(libp2pOpts, libp2p.EnableRelay(), libp2p.EnableRelayService()) - } h, err := libp2p.New(libp2pOpts...) require.NoError(t, err) return h @@ -110,9 +106,6 @@ var transportsToTest = []TransportTestCase{ } else { libp2pOpts = append(libp2pOpts, libp2p.ListenAddrStrings("/ip4/127.0.0.1/tcp/0")) } - if opts.EnabledRelay { - libp2pOpts = append(libp2pOpts, libp2p.EnableRelay(), libp2p.EnableRelayService()) - } h, err := libp2p.New(libp2pOpts...) require.NoError(t, err) return h @@ -130,9 +123,6 @@ var transportsToTest = []TransportTestCase{ } else { libp2pOpts = append(libp2pOpts, libp2p.ListenAddrStrings("/ip4/127.0.0.1/tcp/0")) } - if opts.EnabledRelay { - libp2pOpts = append(libp2pOpts, libp2p.EnableRelay(), libp2p.EnableRelayService()) - } h, err := libp2p.New(libp2pOpts...) require.NoError(t, err) return h @@ -148,9 +138,6 @@ var transportsToTest = []TransportTestCase{ } else { libp2pOpts = append(libp2pOpts, libp2p.ListenAddrStrings("/ip4/127.0.0.1/tcp/0/ws")) } - if opts.EnabledRelay { - libp2pOpts = append(libp2pOpts, libp2p.EnableRelay(), libp2p.EnableRelayService()) - } h, err := libp2p.New(libp2pOpts...) require.NoError(t, err) return h @@ -165,9 +152,6 @@ var transportsToTest = []TransportTestCase{ } else { libp2pOpts = append(libp2pOpts, libp2p.ListenAddrStrings("/ip4/127.0.0.1/tcp/0/ws")) } - if opts.EnabledRelay { - libp2pOpts = append(libp2pOpts, libp2p.EnableRelay(), libp2p.EnableRelayService()) - } h, err := libp2p.New(libp2pOpts...) require.NoError(t, err) return h @@ -182,9 +166,6 @@ var transportsToTest = []TransportTestCase{ } else { libp2pOpts = append(libp2pOpts, libp2p.ListenAddrStrings("/ip4/127.0.0.1/udp/0/quic-v1")) } - if opts.EnabledRelay { - libp2pOpts = append(libp2pOpts, libp2p.EnableRelay(), libp2p.EnableRelayService()) - } h, err := libp2p.New(libp2pOpts...) require.NoError(t, err) return h @@ -199,9 +180,6 @@ var transportsToTest = []TransportTestCase{ } else { libp2pOpts = append(libp2pOpts, libp2p.ListenAddrStrings("/ip4/127.0.0.1/udp/0/quic-v1/webtransport")) } - if opts.EnabledRelay { - libp2pOpts = append(libp2pOpts, libp2p.EnableRelay(), libp2p.EnableRelayService()) - } h, err := libp2p.New(libp2pOpts...) require.NoError(t, err) return h @@ -217,8 +195,19 @@ var transportsToTest = []TransportTestCase{ } else { libp2pOpts = append(libp2pOpts, libp2p.ListenAddrStrings("/ip4/127.0.0.1/udp/0/webrtc-direct")) } - if opts.EnabledRelay { - libp2pOpts = append(libp2pOpts, libp2p.EnableRelay(), libp2p.EnableRelayService()) + h, err := libp2p.New(libp2pOpts...) + require.NoError(t, err) + return h + }, + }, + { + Name: "circuit-v2", + HostGenerator: func(t *testing.T, opts TransportTestCaseOpts) host.Host { + libp2pOpts := transformOpts(opts) + if opts.NoListen { + libp2pOpts = append(libp2pOpts, libp2p.NoListenAddrs) + } else { + libp2pOpts = append(libp2pOpts, libp2p.ListenAddrStrings("/ip4/127.0.0.1/udp/0/quic-v1")) } h, err := libp2p.New(libp2pOpts...) require.NoError(t, err) @@ -870,10 +859,6 @@ func TestConnClosedWhenRemoteCloses(t *testing.T) { func TestConnRelay(t *testing.T) { for _, tc := range transportsToTest { - if tc.Name != RelayTestOnTransportName { - continue - } - t.Run(tc.Name, func(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() @@ -881,7 +866,7 @@ func TestConnRelay(t *testing.T) { var hosts []host.Host // Set host for i := 0; i < 3; i++ { - h := tc.HostGenerator(t, TransportTestCaseOpts{EnabledRelay: true}) + h := tc.HostGenerator(t, TransportTestCaseOpts{}) hosts = append(hosts, h) }