WIP: Feat/memory transport

p2p/test/transport/transport_test.go

@@ -31,8 +31,9 @@ import (
 	"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"
-	"github.com/libp2p/go-libp2p/p2p/transport/tcp"
+	libp2pmemory "github.com/libp2p/go-libp2p/p2p/transport/memory"
 	libp2pwebrtc "github.com/libp2p/go-libp2p/p2p/transport/webrtc"
+  "github.com/libp2p/go-libp2p/p2p/transport/tcp"
 	"go.uber.org/mock/gomock"
 
 	ma "github.com/multiformats/go-multiaddr"
@@ -156,7 +157,6 @@ var transportsToTest = []TransportTestCase{
 		Name: "WebSocket-Shared",
 		HostGenerator: func(t *testing.T, opts TransportTestCaseOpts) host.Host {
 			libp2pOpts := transformOpts(opts)
-			libp2pOpts = append(libp2pOpts, libp2p.ShareTCPListener())
 			if opts.NoListen {
 				libp2pOpts = append(libp2pOpts, libp2p.NoListenAddrs)
 			} else {
@@ -168,56 +168,57 @@ var transportsToTest = []TransportTestCase{
 		},
 	},
 	{
-		Name: "WebSocket",
+		Name: "QUIC",
 		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/tcp/0/ws"))
+				libp2pOpts = append(libp2pOpts, libp2p.ListenAddrStrings("/ip4/127.0.0.1/udp/0/quic-v1"))
 			}
 			h, err := libp2p.New(libp2pOpts...)
 			require.NoError(t, err)
 			return h
 		},
 	},
 	{
-		Name: "QUIC",
+		Name: "WebTransport",
 		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"))
+				libp2pOpts = append(libp2pOpts, libp2p.ListenAddrStrings("/ip4/127.0.0.1/udp/0/quic-v1/webtransport"))
 			}
 			h, err := libp2p.New(libp2pOpts...)
 			require.NoError(t, err)
 			return h
 		},
 	},
 	{
-		Name: "WebTransport",
+		Name: "WebRTC",
 		HostGenerator: func(t *testing.T, opts TransportTestCaseOpts) host.Host {
 			libp2pOpts := transformOpts(opts)
+			libp2pOpts = append(libp2pOpts, libp2p.Transport(libp2pwebrtc.New))
 			if opts.NoListen {
 				libp2pOpts = append(libp2pOpts, libp2p.NoListenAddrs)
 			} else {
-				libp2pOpts = append(libp2pOpts, libp2p.ListenAddrStrings("/ip4/127.0.0.1/udp/0/quic-v1/webtransport"))
+				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: "WebRTC",
+		Name: "Memory",
 		HostGenerator: func(t *testing.T, opts TransportTestCaseOpts) host.Host {
 			libp2pOpts := transformOpts(opts)
-			libp2pOpts = append(libp2pOpts, libp2p.Transport(libp2pwebrtc.New))
+			libp2pOpts = append(libp2pOpts, libp2p.Transport(libp2pmemory.NewTransport))
 			if opts.NoListen {
 				libp2pOpts = append(libp2pOpts, libp2p.NoListenAddrs)
 			} else {
-				libp2pOpts = append(libp2pOpts, libp2p.ListenAddrStrings("/ip4/127.0.0.1/udp/0/webrtc-direct"))
+				libp2pOpts = append(libp2pOpts, libp2p.ListenAddrStrings("/memory/1234"))
 			}
 			h, err := libp2p.New(libp2pOpts...)
 			require.NoError(t, err)

p2p/transport/memory/conn.go

@@ -0,0 +1,146 @@
+package memory
+
+import (
+	"context"
+	"log"
+	"sync"
+	"sync/atomic"
+
+	ic "github.com/libp2p/go-libp2p/core/crypto"
+	"github.com/libp2p/go-libp2p/core/network"
+	"github.com/libp2p/go-libp2p/core/peer"
+	tpt "github.com/libp2p/go-libp2p/core/transport"
+	ma "github.com/multiformats/go-multiaddr"
+)
+
+type conn struct {
+	id    int64
+	rconn *conn
+
+	scope     network.ConnManagementScope
+	listener  *listener
+	transport *transport
+
+	localPeer      peer.ID
+	localMultiaddr ma.Multiaddr
+
+	remotePeerID    peer.ID
+	remotePubKey    ic.PubKey
+	remoteMultiaddr ma.Multiaddr
+
+	mu sync.Mutex
+
+	closed    atomic.Bool
+	closeOnce sync.Once
+
+	streamC chan *stream
+	streams map[int64]network.MuxedStream
+}
+
+var _ tpt.CapableConn = &conn{}
+
+func newConnection(
+	t *transport,
+	s *stream,
+	localPeer peer.ID,
+	localMultiaddr ma.Multiaddr,
+	remotePubKey ic.PubKey,
+	remotePeer peer.ID,
+	remoteMultiaddr ma.Multiaddr,
+) *conn {
+	c := &conn{
+		id:              connCounter.Add(1),
+		transport:       t,
+		localPeer:       localPeer,
+		localMultiaddr:  localMultiaddr,
+		remotePubKey:    remotePubKey,
+		remotePeerID:    remotePeer,
+		remoteMultiaddr: remoteMultiaddr,
+		streamC:         make(chan *stream, 1),
+		streams:         make(map[int64]network.MuxedStream),
+	}
+
+	c.addStream(s.id, s)
+	return c
+}
+
+func (c *conn) Close() error {
+	c.closeOnce.Do(func() {
+		c.closed.Store(true)
+		go c.rconn.Close()
+		c.teardown()
+	})
+
+	return nil
+}
+
+func (c *conn) IsClosed() bool {
+	return c.closed.Load()
+}
+
+func (c *conn) OpenStream(ctx context.Context) (network.MuxedStream, error) {
+	sl, sr := newStreamPair()
+	sl.conn = c
+	c.addStream(sl.id, sl)
+	log.Println("opening stream", sl.id, sr.id)
+
+	c.rconn.streamC <- sr
+	return sl, nil
+}
+
+func (c *conn) AcceptStream() (network.MuxedStream, error) {
+	in := <-c.streamC
+	in.conn = c
+	c.addStream(in.id, in)
+	return in, nil
+}
+
+func (c *conn) LocalPeer() peer.ID { return c.localPeer }
+
+// RemotePeer returns the peer ID of the remote peer.
+func (c *conn) RemotePeer() peer.ID { return c.remotePeerID }
+
+// RemotePublicKey returns the public pkey of the remote peer.
+func (c *conn) RemotePublicKey() ic.PubKey { return c.remotePubKey }
+
+// LocalMultiaddr returns the local Multiaddr associated
+func (c *conn) LocalMultiaddr() ma.Multiaddr { return c.localMultiaddr }
+
+// RemoteMultiaddr returns the remote Multiaddr associated
+func (c *conn) RemoteMultiaddr() ma.Multiaddr { return c.remoteMultiaddr }
+
+func (c *conn) Transport() tpt.Transport {
+	return c.transport
+}
+
+func (c *conn) Scope() network.ConnScope {
+	return c.scope
+}
+
+// ConnState is the state of security connection.
+func (c *conn) ConnState() network.ConnectionState {
+	return network.ConnectionState{Transport: "memory"}
+}
+
+func (c *conn) addStream(id int64, stream network.MuxedStream) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	c.streams[id] = stream
+}
+
+func (c *conn) removeStream(id int64) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	delete(c.streams, id)
+}
+
+func (c *conn) teardown() {
+	for id, s := range c.streams {
+		log.Println("tearing down stream", id)
+		s.Reset()
+	}
+
+	// TODO: remove self from listener
+}

p2p/transport/memory/conn_test.go

@@ -0,0 +1 @@
+package memory

p2p/transport/memory/hub.go

@@ -0,0 +1,80 @@
+package memory
+
+import (
+	ic "github.com/libp2p/go-libp2p/core/crypto"
+	"github.com/libp2p/go-libp2p/core/peer"
+	ma "github.com/multiformats/go-multiaddr"
+	mafmt "github.com/multiformats/go-multiaddr-fmt"
+	"sync"
+	"sync/atomic"
+)
+
+var (
+	connCounter     atomic.Int64
+	streamCounter   atomic.Int64
+	listenerCounter atomic.Int64
+	dialMatcher     = mafmt.Base(ma.P_MEMORY)
+	memhub          = newHub()
+)
+
+type hub struct {
+	mu        sync.RWMutex
+	closeOnce sync.Once
+	pubKeys   map[peer.ID]ic.PubKey
+	listeners map[string]*listener
+}
+
+func newHub() *hub {
+	return &hub{
+		pubKeys:   make(map[peer.ID]ic.PubKey),
+		listeners: make(map[string]*listener),
+	}
+}
+
+func (h *hub) addListener(addr string, l *listener) {
+	h.mu.Lock()
+	defer h.mu.Unlock()
+
+	h.listeners[addr] = l
+}
+
+func (h *hub) removeListener(addr string, l *listener) {
+	h.mu.Lock()
+	defer h.mu.Unlock()
+
+	delete(h.listeners, addr)
+}
+
+func (h *hub) getListener(addr string) (*listener, bool) {
+	h.mu.RLock()
+	defer h.mu.RUnlock()
+
+	l, ok := h.listeners[addr]
+	return l, ok
+}
+
+func (h *hub) addPubKey(p peer.ID, pk ic.PubKey) {
+	h.mu.Lock()
+	defer h.mu.Unlock()
+
+	h.pubKeys[p] = pk
+}
+
+func (h *hub) getPubKey(p peer.ID) (ic.PubKey, bool) {
+	h.mu.RLock()
+	defer h.mu.RUnlock()
+
+	pk, ok := h.pubKeys[p]
+	return pk, ok
+}
+
+func (h *hub) close() {
+	h.closeOnce.Do(func() {
+		h.mu.Lock()
+		defer h.mu.Unlock()
+
+		for _, l := range h.listeners {
+			l.Close()
+		}
+	})
+}

p2p/transport/memory/listener.go

@@ -0,0 +1,75 @@
+package memory
+
+import (
+	"context"
+	"net"
+	"sync"
+
+	tpt "github.com/libp2p/go-libp2p/core/transport"
+	ma "github.com/multiformats/go-multiaddr"
+)
+
+const (
+	listenerQueueSize = 16
+)
+
+type listener struct {
+	id int64
+
+	t      *transport
+	ctx    context.Context
+	cancel context.CancelFunc
+	laddr  ma.Multiaddr
+
+	mu          sync.Mutex
+	connCh      chan *conn
+	connections map[int64]*conn
+}
+
+func (l *listener) Multiaddr() ma.Multiaddr {
+	return l.laddr
+}
+
+func newListener(t *transport, laddr ma.Multiaddr) *listener {
+	ctx, cancel := context.WithCancel(context.Background())
+	return &listener{
+		id:          listenerCounter.Add(1),
+		t:           t,
+		ctx:         ctx,
+		cancel:      cancel,
+		laddr:       laddr,
+		connCh:      make(chan *conn, listenerQueueSize),
+		connections: make(map[int64]*conn),
+	}
+}
+
+// Accept accepts new connections.
+func (l *listener) Accept() (tpt.CapableConn, error) {
+	select {
+	case <-l.ctx.Done():
+		return nil, tpt.ErrListenerClosed
+	case c, ok := <-l.connCh:
+		if !ok {
+			return nil, tpt.ErrListenerClosed
+		}
+
+		l.mu.Lock()
+		defer l.mu.Unlock()
+
+		c.listener = l
+		c.transport = l.t
+		l.connections[c.id] = c
+		return c, nil
+	}
+}
+
+// Close closes the listener.
+func (l *listener) Close() error {
+	l.cancel()
+	return nil
+}
+
+// Addr returns the address of this listener.
+func (l *listener) Addr() net.Addr {
+	return nil
+}