extract out yamux code in favor of modularity

.gx/lastpubver

@@ -1 +1 @@
-1.1.0: QmbM19LB6CWweXhRE6j82qEPPcxTJqRhhsk3EexyfwTQV8
+1.2.0: QmPpRcbNUXauP3zWZ1NJMLWpe4QnmEHrd2ba2D3yqWznw7

convert.go

@@ -6,7 +6,6 @@ import (
 	"strings"
 
 	ma "github.com/jbenet/go-multiaddr"
-	utp "github.com/jbenet/go-multiaddr-net/utp"
 )
 
 var errIncorrectNetAddr = fmt.Errorf("incorrect network addr conversion")
@@ -58,8 +57,6 @@ func parseBasicNetMaddr(maddr ma.Multiaddr) (net.Addr, error) {
 		return net.ResolveTCPAddr(network, host)
 	case "udp", "udp4", "udp6":
 		return net.ResolveUDPAddr(network, host)
-	case "utp", "utp4", "utp6":
-		return utp.ResolveAddr(network, host)
 	case "ip", "ip4", "ip6":
 		return net.ResolveIPAddr(network, host)
 	}
@@ -95,9 +92,6 @@ func DialArgs(m ma.Multiaddr) (string, string, error) {
 	}
 
 	network := parts[2]
-	if parts[2] == "udp" && len(parts) > 4 && parts[4] == "utp" {
-		network = parts[4]
-	}
 
 	var host string
 	switch parts[0] {
@@ -155,34 +149,6 @@ func parseUdpNetAddr(a net.Addr) (ma.Multiaddr, error) {
 	return ipm.Encapsulate(udpm), nil
 }
 
-func parseUtpNetAddr(a net.Addr) (ma.Multiaddr, error) {
-	acc, ok := a.(*utp.Addr)
-	if !ok {
-		return nil, errIncorrectNetAddr
-	}
-
-	// Get UDP Addr
-	ac, ok := acc.Child().(*net.UDPAddr)
-	if !ok {
-		return nil, errIncorrectNetAddr
-	}
-
-	// Get IP Addr
-	ipm, err := FromIP(ac.IP)
-	if err != nil {
-		return nil, errIncorrectNetAddr
-	}
-
-	// Get UDP Addr
-	utpm, err := ma.NewMultiaddr(fmt.Sprintf("/udp/%d/utp", ac.Port))
-	if err != nil {
-		return nil, errIncorrectNetAddr
-	}
-
-	// Encapsulate
-	return ipm.Encapsulate(utpm), nil
-}
-
 func parseIpNetAddr(a net.Addr) (ma.Multiaddr, error) {
 	ac, ok := a.(*net.IPAddr)
 	if !ok {

convert_test.go

@@ -5,7 +5,6 @@ import (
 	"testing"
 
 	ma "github.com/jbenet/go-multiaddr"
-	mautp "github.com/jbenet/go-multiaddr-net/utp"
 )
 
 type GenFunc func() (ma.Multiaddr, error)
@@ -89,27 +88,17 @@ func TestFromUDP(t *testing.T) {
 	})
 }
 
-func TestFromUTP(t *testing.T) {
-	a := &net.UDPAddr{IP: net.ParseIP("10.20.30.40"), Port: 1234}
-	testConvert(t, "/ip4/10.20.30.40/udp/1234/utp", func() (ma.Multiaddr, error) {
-		return FromNetAddr(mautp.MakeAddr(a))
-	})
-}
-
 func TestThinWaist(t *testing.T) {
 	addrs := map[string]bool{
 		"/ip4/127.0.0.1/udp/1234":              true,
 		"/ip4/127.0.0.1/tcp/1234":              true,
-		"/ip4/127.0.0.1/udp/1234/utp":          true,
 		"/ip4/127.0.0.1/udp/1234/tcp/1234":     true,
 		"/ip4/127.0.0.1/tcp/12345/ip4/1.2.3.4": true,
 		"/ip6/::1/tcp/80":                      true,
 		"/ip6/::1/udp/80":                      true,
 		"/ip6/::1":                             true,
-		"/ip6/::1/utp":                         false,
 		"/tcp/1234/ip4/1.2.3.4":                false,
 		"/tcp/1234":                            false,
-		"/tcp/1234/utp":                        false,
 		"/tcp/1234/udp/1234":                   false,
 		"/ip4/1.2.3.4/ip4/2.3.4.5":             true,
 		"/ip6/::1/ip4/2.3.4.5":                 true,
@@ -150,8 +139,6 @@ func TestDialArgs(t *testing.T) {
 
 	test("/ip4/127.0.0.1/udp/1234", "udp4", "127.0.0.1:1234")
 	test("/ip4/127.0.0.1/tcp/4321", "tcp4", "127.0.0.1:4321")
-	test("/ip4/127.0.0.1/udp/1234/utp", "utp4", "127.0.0.1:1234")
 	test("/ip6/::1/udp/1234", "udp6", "[::1]:1234")
 	test("/ip6/::1/tcp/4321", "tcp6", "[::1]:4321")
-	test("/ip6/::1/udp/1234/utp", "utp6", "[::1]:1234")
 }

net.go

@@ -5,7 +5,6 @@ import (
 	"net"
 
 	ma "github.com/jbenet/go-multiaddr"
-	mautp "github.com/jbenet/go-multiaddr-net/utp"
 )
 
 // Conn is the equivalent of a net.Conn object. It is the
@@ -114,16 +113,6 @@ func (d *Dialer) Dial(remote ma.Multiaddr) (Conn, error) {
 		if err != nil {
 			return nil, err
 		}
-	case "utp", "utp4", "utp6":
-		utpd := mautp.Dialer{
-			Timeout:   d.Timeout,
-			LocalAddr: d.Dialer.LocalAddr,
-		}
-		// construct utp dialer, with options on our net.Dialer
-		nconn, err = utpd.Dial(rnet, rnaddr)
-		if err != nil {
-			return nil, err
-		}
 	}
 
 	// get local address (pre-specified or assigned within net.Conn)
@@ -224,13 +213,7 @@ func Listen(laddr ma.Multiaddr) (Listener, error) {
 		return nil, err
 	}
 
-	var nl net.Listener
+	nl, err := net.Listen(lnet, lnaddr)
-	switch lnet {
-	case "utp", "utp4", "utp6":
-		nl, err = mautp.Listen(lnet, lnaddr)
-	default:
-		nl, err = net.Listen(lnet, lnaddr)
-	}
 	if err != nil {
 		return nil, err
 	}

net_test.go

@@ -181,7 +181,6 @@ func TestListenAddrs(t *testing.T) {
 	test("/ip6/::/tcp/4324", "", true)
 	test("/ip6/::/udp/4325", "", false)
 	test("/ip6/::/udp/4326/udt", "", false)
-	// test("/ip4/127.0.0.1/udp/4326/utp", true)
 }
 
 func TestListenAndDial(t *testing.T) {
@@ -245,68 +244,6 @@ func TestListenAndDial(t *testing.T) {
 	wg.Wait()
 }
 
-func TestListenAndDialUTP(t *testing.T) {
-	maddr := newMultiaddr(t, "/ip4/127.0.0.1/udp/4323/utp")
-	listener, err := Listen(maddr)
-	if err != nil {
-		t.Fatal("failed to listen: ", err)
-	}
-
-	var wg sync.WaitGroup
-	wg.Add(1)
-	go func() {
-
-		cB, err := listener.Accept()
-		if err != nil {
-			t.Fatal("failed to accept")
-		}
-
-		if !cB.LocalMultiaddr().Equal(maddr) {
-			t.Fatal("local multiaddr not equal:", maddr, cB.LocalMultiaddr())
-		}
-
-		defer cB.Close()
-
-		// echo out
-		buf := make([]byte, 1024)
-		for {
-			_, err := cB.Read(buf)
-			if err != nil {
-				break
-			}
-			cB.Write(buf)
-		}
-
-		wg.Done()
-	}()
-
-	cA, err := Dial(newMultiaddr(t, "/ip4/127.0.0.1/udp/4323/utp"))
-	if err != nil {
-		t.Fatal("failed to dial", err)
-	}
-
-	buf := make([]byte, 1024)
-	if _, err := cA.Write([]byte("beep boop")); err != nil {
-		t.Fatal("failed to write:", err)
-	}
-
-	if _, err := cA.Read(buf); err != nil {
-		t.Fatal("failed to read:", buf, err)
-	}
-
-	if !bytes.Equal(buf[:9], []byte("beep boop")) {
-		t.Fatal("failed to echo:", buf)
-	}
-
-	maddr2 := cA.RemoteMultiaddr()
-	if !maddr2.Equal(maddr) {
-		t.Fatal("remote multiaddr not equal:", maddr, maddr2)
-	}
-
-	cA.Close()
-	wg.Wait()
-}
-
 func TestIPLoopback(t *testing.T) {
 	if IP4Loopback.String() != "/ip4/127.0.0.1" {
 		t.Error("IP4Loopback incorrect:", IP4Loopback)

package.json

@@ -7,12 +7,6 @@
     "dvcsimport": "github.com/jbenet/go-multiaddr-net"
   },
   "gxDependencies": [
-    {
-      "author": "whyrusleeping",
-      "hash": "QmaxuoSyFFzKgrujaburn4j3MQWFQu8ASqVSwrMER6Mk9L",
-      "name": "utp",
-      "version": "0.0.0"
-    },
     {
       "author": "whyrusleeping",
       "hash": "QmYzDkkgAEmrcNzFCiYo6L1dTX4EAG1gZkbtdbd9trL4vd",
@@ -24,5 +18,5 @@
   "language": "go",
   "license": "",
   "name": "go-multiaddr-net",
-  "version": "1.1.0"
+  "version": "1.2.0"
 }

registry.go

@@ -17,7 +17,6 @@ func init() {
 	defaultCodecs = NewCodecMap()
 	defaultCodecs.RegisterNetCodec(tcpAddrSpec)
 	defaultCodecs.RegisterNetCodec(udpAddrSpec)
-	defaultCodecs.RegisterNetCodec(utpAddrSpec)
 	defaultCodecs.RegisterNetCodec(ip4AddrSpec)
 	defaultCodecs.RegisterNetCodec(ip6AddrSpec)
 	defaultCodecs.RegisterNetCodec(ipnetAddrSpec)
@@ -85,13 +84,6 @@ var udpAddrSpec = &NetCodec{
 	ConvertMultiaddr: parseBasicNetMaddr,
 }
 
-var utpAddrSpec = &NetCodec{
-	ProtocolName:     "utp",
-	NetAddrNetworks:  []string{"utp", "utp4", "utp6"},
-	ParseNetAddr:     parseUtpNetAddr,
-	ConvertMultiaddr: parseBasicNetMaddr,
-}
-
 var ip4AddrSpec = &NetCodec{
 	ProtocolName:     "ip4",
 	NetAddrNetworks:  []string{"ip4"},

utp/utp_util.go

@@ -1,105 +0,0 @@
-package utp
-
-import (
-	"errors"
-	"net"
-	"time"
-
-	utp "github.com/anacrolix/utp"
-)
-
-type Listener struct {
-	*utp.Socket
-}
-
-type Conn struct {
-	net.Conn
-}
-
-type Addr struct {
-	net   string
-	child net.Addr
-}
-
-func (ca *Addr) Network() string {
-	return ca.net
-}
-
-func (ca *Addr) String() string {
-	return ca.child.String()
-}
-
-func (ca *Addr) Child() net.Addr {
-	return ca.child
-}
-
-func MakeAddr(a net.Addr) net.Addr {
-	return &Addr{
-		net:   "utp",
-		child: a,
-	}
-}
-
-func ResolveAddr(network string, host string) (net.Addr, error) {
-	a, err := net.ResolveUDPAddr("udp"+network[3:], host)
-	if err != nil {
-		return nil, err
-	}
-
-	return MakeAddr(a), nil
-}
-
-func (u *Conn) LocalAddr() net.Addr {
-	return MakeAddr(u.Conn.LocalAddr())
-}
-
-func (u *Conn) RemoteAddr() net.Addr {
-	return MakeAddr(u.Conn.RemoteAddr())
-}
-
-func Listen(network string, laddr string) (net.Listener, error) {
-	switch network {
-	case "utp", "utp4", "utp6":
-		s, err := utp.NewSocket("udp"+network[3:], laddr)
-		if err != nil {
-			return nil, err
-		}
-
-		return &Listener{s}, nil
-
-	default:
-		return nil, errors.New("unrecognized network: " + network)
-	}
-}
-
-func (u *Listener) Accept() (net.Conn, error) {
-	c, err := u.Socket.Accept()
-	if err != nil {
-		return nil, err
-	}
-
-	return &Conn{c}, nil
-}
-
-func (u *Listener) Addr() net.Addr {
-	return MakeAddr(u.Socket.Addr())
-}
-
-type Dialer struct {
-	Timeout   time.Duration
-	LocalAddr net.Addr
-}
-
-func (d *Dialer) Dial(rnet string, raddr string) (net.Conn, error) {
-	if d.LocalAddr != nil {
-		s, err := utp.NewSocket(d.LocalAddr.Network(), d.LocalAddr.String())
-		if err != nil {
-			return nil, err
-		}
-
-		// zero timeout is the same as calling s.Dial()
-		return s.DialTimeout(raddr, d.Timeout)
-	}
-
-	return utp.DialTimeout(raddr, d.Timeout)
-}