feat(network): Add ConnAs

ConnAs works in a similar way to errors.As. It allows a user to cut
through the interface layers and extract a specific type of connection
if available.

This serves as a sort of escape hatch to allow users to leverage some
connection specific feature without having to support that feature for
all connections. Getting RTT information is one example.

It also allows us, within the library, to get specific types of
connections out of the interface box. This would have been useful in the
recent changes in tcpreuse. See
#3181 and
#3142.

Getting access to the underlying type can lead to hard to debug issues.
For example, if a user mutates connection state on the underlying type,
hooks that relied on only mutating that state from the wrapped
connection would never be called.

It is up to the user to ensure they are using this safely.

Author: MarcoPolo

core/network/conn.go

@@ -141,3 +141,10 @@ type ConnScoper interface {
 	// Scope returns the user view of this connection's resource scope
 	Scope() ConnScope
 }
+
+func ConnAs(c Conn, target any) bool {
+	if x, ok := c.(interface{ As(any) bool }); ok && x.As(target) {
+		return true
+	}
+	return false
+}

libp2p_test.go

@@ -40,6 +40,8 @@ import (
 	libp2pwebrtc "github.com/libp2p/go-libp2p/p2p/transport/webrtc"
 	"github.com/libp2p/go-libp2p/p2p/transport/websocket"
 	webtransport "github.com/libp2p/go-libp2p/p2p/transport/webtransport"
+	"github.com/libp2p/go-yamux/v5"
+	quicgo "github.com/quic-go/quic-go"
 	"go.uber.org/goleak"
 
 	ma "github.com/multiformats/go-multiaddr"
@@ -825,3 +827,49 @@ func BenchmarkAllAddrs(b *testing.B) {
 		addrsHost.AllAddrs()
 	}
 }
+
+func TestConnAs(t *testing.T) {
+	t.Run("quic conns", func(t *testing.T) {
+		h1, err := New(ListenAddrStrings(
+			"/ip4/0.0.0.0/udp/0/quic-v1",
+		))
+		require.NoError(t, err)
+		defer h1.Close()
+		h2, err := New(ListenAddrStrings(
+			"/ip4/0.0.0.0/udp/0/quic-v1",
+		))
+		require.NoError(t, err)
+		defer h2.Close()
+		err = h1.Connect(context.Background(), peer.AddrInfo{
+			ID:    h2.ID(),
+			Addrs: h2.Addrs(),
+		})
+		require.NoError(t, err)
+		c := h1.Network().ConnsToPeer(h2.ID())[0]
+
+		var quicConn *quicgo.Conn
+		require.True(t, network.ConnAs(c, &quicConn))
+	})
+
+	t.Run("TCP conn with metrics", func(t *testing.T) {
+		h1, err := New(ListenAddrStrings(
+			"/ip4/0.0.0.0/tcp/0",
+		), Transport(tcp.NewTCPTransport, tcp.WithMetrics()))
+		require.NoError(t, err)
+		defer h1.Close()
+		h2, err := New(ListenAddrStrings(
+			"/ip4/0.0.0.0/tcp/0",
+		), Transport(tcp.NewTCPTransport, tcp.WithMetrics()))
+		require.NoError(t, err)
+		defer h2.Close()
+		err = h1.Connect(context.Background(), peer.AddrInfo{
+			ID:    h2.ID(),
+			Addrs: h2.Addrs(),
+		})
+		require.NoError(t, err)
+		c := h1.Network().ConnsToPeer(h2.ID())[0]
+
+		var yamuxSession *yamux.Session
+		require.True(t, network.ConnAs(c, &yamuxSession))
+	})
+}

p2p/muxer/yamux/conn.go

@@ -13,6 +13,14 @@ type conn yamux.Session
 
 var _ network.MuxedConn = &conn{}
 
+func (c *conn) As(target any) bool {
+	if t, ok := target.(**yamux.Session); ok {
+		*t = (*yamux.Session)(c)
+		return true
+	}
+	return false
+}
+
 // NewMuxedConn constructs a new MuxedConn from a yamux.Session.
 func NewMuxedConn(m *yamux.Session) network.MuxedConn {
 	return (*conn)(m)

p2p/net/swarm/swarm.go

@@ -833,6 +833,13 @@ func wrapWithMetrics(capableConn transport.CapableConn, metricsTracer MetricsTra
 	return c
 }
 
+func (c *connWithMetrics) As(target any) bool {
+	if x, ok := c.CapableConn.(interface{ As(any) bool }); ok && x.As(target) {
+		return true
+	}
+	return false
+}
+
 func (c *connWithMetrics) completedHandshake() {
 	c.metricsTracer.CompletedHandshake(time.Since(c.opened), c.ConnState(), c.LocalMultiaddr())
 }

p2p/net/swarm/swarm_conn.go

@@ -42,6 +42,13 @@ type Conn struct {
 
 var _ network.Conn = &Conn{}
 
+func (c *Conn) As(target any) bool {
+	if x, ok := c.conn.(interface{ As(any) bool }); ok && x.As(target) {
+		return true
+	}
+	return false
+}
+
 func (c *Conn) IsClosed() bool {
 	return c.conn.IsClosed()
 }

p2p/net/upgrader/conn.go

@@ -23,6 +23,13 @@ type transportConn struct {
 
 var _ transport.CapableConn = &transportConn{}
 
+func (c *transportConn) As(target any) bool {
+	if x, ok := c.MuxedConn.(interface{ As(any) bool }); ok && x.As(target) {
+		return true
+	}
+	return false
+}
+
 func (t *transportConn) Transport() transport.Transport {
 	return t.transport
 }

p2p/transport/quic/conn.go

@@ -25,6 +25,15 @@ type conn struct {
 	remoteMultiaddr ma.Multiaddr
 }
 
+func (c *conn) As(target any) bool {
+	if t, ok := target.(**quic.Conn); ok {
+		*t = c.quicConn
+		return true
+	}
+
+	return false
+}
+
 var _ tpt.CapableConn = &conn{}
 
 // Close closes the connection.