Merge pull request #37 from ipfs/deps/cleanup

Deps/cleanup

p2p/net/mock/mock_peernet.go

@@ -6,10 +6,9 @@ import (
 	"sync"
 
 	inet "github.com/ipfs/go-libp2p/p2p/net"
-	peer "github.com/ipfs/go-libp2p/p2p/peer"
-
 	"gx/ipfs/QmQopLATEYMNg7dVqZRNDfeE2S1yKy8zrRh5xnYiuqeZBn/goprocess"
 	goprocessctx "gx/ipfs/QmQopLATEYMNg7dVqZRNDfeE2S1yKy8zrRh5xnYiuqeZBn/goprocess/context"
+	peer "gx/ipfs/QmY1xNhBfF9xA1pmD8yejyQAyd77K68qNN6JPM1CN2eiRu/go-libp2p-peer"
 	context "gx/ipfs/QmZy2y8t9zQH2a1b8q2ZSLKp17ATuJoCNxxyMFG5qFExpt/go-net/context"
 	ma "gx/ipfs/QmcobAGsCjYt5DXoq9et9L8yR8er7o7Cu3DTvpaq12jYSz/go-multiaddr"
 )

p2p/net/mock/mock_printer.go

@@ -5,7 +5,7 @@ import (
 	"io"
 
 	inet "github.com/ipfs/go-libp2p/p2p/net"
-	peer "github.com/ipfs/go-libp2p/p2p/peer"
+	peer "gx/ipfs/QmY1xNhBfF9xA1pmD8yejyQAyd77K68qNN6JPM1CN2eiRu/go-libp2p-peer"
 )
 
 // separate object so our interfaces are separate :)

p2p/net/mock/mock_test.go

@@ -10,9 +10,9 @@ import (
 	"time"
 
 	inet "github.com/ipfs/go-libp2p/p2p/net"
-	peer "github.com/ipfs/go-libp2p/p2p/peer"
 	protocol "github.com/ipfs/go-libp2p/p2p/protocol"
 	testutil "github.com/ipfs/go-libp2p/testutil"
+	peer "gx/ipfs/QmY1xNhBfF9xA1pmD8yejyQAyd77K68qNN6JPM1CN2eiRu/go-libp2p-peer"
 
 	detectrace "gx/ipfs/QmQHGMVmrsgmqUG8ih3puNXUJneSpi13dkcZpzLKkskUkH/go-detect-race"
 	context "gx/ipfs/QmZy2y8t9zQH2a1b8q2ZSLKp17ATuJoCNxxyMFG5qFExpt/go-net/context"

p2p/net/swarm/dial_test.go

@@ -8,10 +8,9 @@ import (
 	"time"
 
 	addrutil "github.com/ipfs/go-libp2p/p2p/net/swarm/addr"
-	peer "github.com/ipfs/go-libp2p/p2p/peer"
-
 	testutil "github.com/ipfs/go-libp2p/testutil"
 	ci "github.com/ipfs/go-libp2p/testutil/ci"
+	peer "gx/ipfs/QmY1xNhBfF9xA1pmD8yejyQAyd77K68qNN6JPM1CN2eiRu/go-libp2p-peer"
 
 	manet "gx/ipfs/QmYVqhVfbK4BKvbW88Lhm26b3ud14sTBvcm1H7uWUx1Fkp/go-multiaddr-net"
 	context "gx/ipfs/QmZy2y8t9zQH2a1b8q2ZSLKp17ATuJoCNxxyMFG5qFExpt/go-net/context"

p2p/net/swarm/peers_test.go

@@ -3,8 +3,7 @@ package swarm
 import (
 	"testing"
 
-	peer "github.com/ipfs/go-libp2p/p2p/peer"
-
+	peer "gx/ipfs/QmY1xNhBfF9xA1pmD8yejyQAyd77K68qNN6JPM1CN2eiRu/go-libp2p-peer"
 	context "gx/ipfs/QmZy2y8t9zQH2a1b8q2ZSLKp17ATuJoCNxxyMFG5qFExpt/go-net/context"
 	ma "gx/ipfs/QmcobAGsCjYt5DXoq9et9L8yR8er7o7Cu3DTvpaq12jYSz/go-multiaddr"
 )

p2p/net/swarm/simul_test.go

@@ -6,8 +6,8 @@ import (
 	"testing"
 	"time"
 
-	peer "github.com/ipfs/go-libp2p/p2p/peer"
 	ci "github.com/ipfs/go-libp2p/testutil/ci"
+	peer "gx/ipfs/QmY1xNhBfF9xA1pmD8yejyQAyd77K68qNN6JPM1CN2eiRu/go-libp2p-peer"
 
 	context "gx/ipfs/QmZy2y8t9zQH2a1b8q2ZSLKp17ATuJoCNxxyMFG5qFExpt/go-net/context"
 	ma "gx/ipfs/QmcobAGsCjYt5DXoq9et9L8yR8er7o7Cu3DTvpaq12jYSz/go-multiaddr"

p2p/net/swarm/swarm.go

@@ -14,16 +14,15 @@ import (
 	conn "github.com/ipfs/go-libp2p/p2p/net/conn"
 	filter "github.com/ipfs/go-libp2p/p2p/net/filter"
 	addrutil "github.com/ipfs/go-libp2p/p2p/net/swarm/addr"
-	transport "github.com/ipfs/go-libp2p/p2p/net/transport"
-	peer "github.com/ipfs/go-libp2p/p2p/peer"
-
 	mafilter "gx/ipfs/QmPwfFAHUmvWDucLHRS9Xz2Kb1TNX2cY4LJ7pQjg9kVcae/multiaddr-filter"
 	"gx/ipfs/QmQopLATEYMNg7dVqZRNDfeE2S1yKy8zrRh5xnYiuqeZBn/goprocess"
 	goprocessctx "gx/ipfs/QmQopLATEYMNg7dVqZRNDfeE2S1yKy8zrRh5xnYiuqeZBn/goprocess/context"
+	transport "gx/ipfs/QmR4HhZm1fL8epXz8661Ru8ks5Y1Uk2u51quAWaCTD1zHg/go-libp2p-transport"
 	pst "gx/ipfs/QmWSJzRkCMJFHYUQZxKwPX8WA7XipaPtfiwMPARP51ymfn/go-stream-muxer"
 	psmss "gx/ipfs/QmWSJzRkCMJFHYUQZxKwPX8WA7XipaPtfiwMPARP51ymfn/go-stream-muxer/multistream"
 	spdy "gx/ipfs/QmWSJzRkCMJFHYUQZxKwPX8WA7XipaPtfiwMPARP51ymfn/go-stream-muxer/spdystream"
 	yamux "gx/ipfs/QmWSJzRkCMJFHYUQZxKwPX8WA7XipaPtfiwMPARP51ymfn/go-stream-muxer/yamux"
+	peer "gx/ipfs/QmY1xNhBfF9xA1pmD8yejyQAyd77K68qNN6JPM1CN2eiRu/go-libp2p-peer"
 	ps "gx/ipfs/QmZK81vcgMhpb2t7GNbozk7qzt6Rj4zFqitpvsWT9mduW8/go-peerstream"
 	context "gx/ipfs/QmZy2y8t9zQH2a1b8q2ZSLKp17ATuJoCNxxyMFG5qFExpt/go-net/context"
 	logging "gx/ipfs/Qmazh5oNUVsDZTs2g59rq8aYQqwpss8tcUWQzor5sCCEuH/go-log"

p2p/net/swarm/swarm_addr_test.go

@@ -5,8 +5,8 @@ import (
 
 	metrics "github.com/ipfs/go-libp2p/p2p/metrics"
 	addrutil "github.com/ipfs/go-libp2p/p2p/net/swarm/addr"
-	peer "github.com/ipfs/go-libp2p/p2p/peer"
 	testutil "github.com/ipfs/go-libp2p/testutil"
+	peer "gx/ipfs/QmY1xNhBfF9xA1pmD8yejyQAyd77K68qNN6JPM1CN2eiRu/go-libp2p-peer"
 
 	context "gx/ipfs/QmZy2y8t9zQH2a1b8q2ZSLKp17ATuJoCNxxyMFG5qFExpt/go-net/context"
 	ma "gx/ipfs/QmcobAGsCjYt5DXoq9et9L8yR8er7o7Cu3DTvpaq12jYSz/go-multiaddr"

p2p/net/swarm/swarm_conn.go

@@ -3,13 +3,13 @@ package swarm
 import (
 	"fmt"
 
-	ic "github.com/ipfs/go-libp2p/p2p/crypto"
 	inet "github.com/ipfs/go-libp2p/p2p/net"
 	conn "github.com/ipfs/go-libp2p/p2p/net/conn"
-	peer "github.com/ipfs/go-libp2p/p2p/peer"
 
+	peer "gx/ipfs/QmY1xNhBfF9xA1pmD8yejyQAyd77K68qNN6JPM1CN2eiRu/go-libp2p-peer"
 	ps "gx/ipfs/QmZK81vcgMhpb2t7GNbozk7qzt6Rj4zFqitpvsWT9mduW8/go-peerstream"
 	context "gx/ipfs/QmZy2y8t9zQH2a1b8q2ZSLKp17ATuJoCNxxyMFG5qFExpt/go-net/context"
+	ic "gx/ipfs/QmaP38GJApheTr84f8R89vsT7oJLQw1AeCz4HqrQgv2njB/go-libp2p-crypto"
 	ma "gx/ipfs/QmcobAGsCjYt5DXoq9et9L8yR8er7o7Cu3DTvpaq12jYSz/go-multiaddr"
 )
 

p2p/net/swarm/swarm_dial.go

@@ -8,10 +8,10 @@ import (
 	"sync"
 	"time"
 
-	lgbl "github.com/ipfs/go-libp2p/loggables"
 	conn "github.com/ipfs/go-libp2p/p2p/net/conn"
 	addrutil "github.com/ipfs/go-libp2p/p2p/net/swarm/addr"
-	peer "github.com/ipfs/go-libp2p/p2p/peer"
+	lgbl "gx/ipfs/QmSyBhZt2upyQ3NJmTpab1pX6hesA59vcYTGmgoDorZZbw/go-libp2p-loggables"
+	peer "gx/ipfs/QmY1xNhBfF9xA1pmD8yejyQAyd77K68qNN6JPM1CN2eiRu/go-libp2p-peer"
 	"gx/ipfs/QmYVqhVfbK4BKvbW88Lhm26b3ud14sTBvcm1H7uWUx1Fkp/go-multiaddr-net"
 	context "gx/ipfs/QmZy2y8t9zQH2a1b8q2ZSLKp17ATuJoCNxxyMFG5qFExpt/go-net/context"
 	ma "gx/ipfs/QmcobAGsCjYt5DXoq9et9L8yR8er7o7Cu3DTvpaq12jYSz/go-multiaddr"

p2p/net/swarm/swarm_listen.go

@@ -3,12 +3,11 @@ package swarm
 import (
 	"fmt"
 
-	lgbl "github.com/ipfs/go-libp2p/loggables"
 	mconn "github.com/ipfs/go-libp2p/p2p/metrics/conn"
 	inet "github.com/ipfs/go-libp2p/p2p/net"
 	conn "github.com/ipfs/go-libp2p/p2p/net/conn"
-	transport "github.com/ipfs/go-libp2p/p2p/net/transport"
-
+	transport "gx/ipfs/QmR4HhZm1fL8epXz8661Ru8ks5Y1Uk2u51quAWaCTD1zHg/go-libp2p-transport"
+	lgbl "gx/ipfs/QmSyBhZt2upyQ3NJmTpab1pX6hesA59vcYTGmgoDorZZbw/go-libp2p-loggables"
 	ps "gx/ipfs/QmZK81vcgMhpb2t7GNbozk7qzt6Rj4zFqitpvsWT9mduW8/go-peerstream"
 	context "gx/ipfs/QmZy2y8t9zQH2a1b8q2ZSLKp17ATuJoCNxxyMFG5qFExpt/go-net/context"
 	ma "gx/ipfs/QmcobAGsCjYt5DXoq9et9L8yR8er7o7Cu3DTvpaq12jYSz/go-multiaddr"

p2p/net/swarm/swarm_net.go

@@ -3,10 +3,9 @@ package swarm
 import (
 	"fmt"
 
-	peer "github.com/ipfs/go-libp2p/p2p/peer"
-
 	metrics "github.com/ipfs/go-libp2p/p2p/metrics"
 	inet "github.com/ipfs/go-libp2p/p2p/net"
+	peer "gx/ipfs/QmY1xNhBfF9xA1pmD8yejyQAyd77K68qNN6JPM1CN2eiRu/go-libp2p-peer"
 
 	"gx/ipfs/QmQopLATEYMNg7dVqZRNDfeE2S1yKy8zrRh5xnYiuqeZBn/goprocess"
 	context "gx/ipfs/QmZy2y8t9zQH2a1b8q2ZSLKp17ATuJoCNxxyMFG5qFExpt/go-net/context"

p2p/net/swarm/swarm_notif_test.go

@@ -5,7 +5,7 @@ import (
 	"time"
 
 	inet "github.com/ipfs/go-libp2p/p2p/net"
-	peer "github.com/ipfs/go-libp2p/p2p/peer"
+	peer "gx/ipfs/QmY1xNhBfF9xA1pmD8yejyQAyd77K68qNN6JPM1CN2eiRu/go-libp2p-peer"
 	context "gx/ipfs/QmZy2y8t9zQH2a1b8q2ZSLKp17ATuJoCNxxyMFG5qFExpt/go-net/context"
 	ma "gx/ipfs/QmcobAGsCjYt5DXoq9et9L8yR8er7o7Cu3DTvpaq12jYSz/go-multiaddr"
 )

p2p/net/swarm/swarm_test.go

@@ -11,8 +11,8 @@ import (
 
 	metrics "github.com/ipfs/go-libp2p/p2p/metrics"
 	inet "github.com/ipfs/go-libp2p/p2p/net"
-	peer "github.com/ipfs/go-libp2p/p2p/peer"
 	testutil "github.com/ipfs/go-libp2p/testutil"
+	peer "gx/ipfs/QmY1xNhBfF9xA1pmD8yejyQAyd77K68qNN6JPM1CN2eiRu/go-libp2p-peer"
 
 	context "gx/ipfs/QmZy2y8t9zQH2a1b8q2ZSLKp17ATuJoCNxxyMFG5qFExpt/go-net/context"
 	ma "gx/ipfs/QmcobAGsCjYt5DXoq9et9L8yR8er7o7Cu3DTvpaq12jYSz/go-multiaddr"

p2p/net/transport/fallback.go

-package transport
-
-import (
-	"fmt"
-
-	mafmt "gx/ipfs/QmWLfU4tstw2aNcTykDm44xbSTCYJ9pUJwfhQCKGwckcHx/mafmt"
-	manet "gx/ipfs/QmYVqhVfbK4BKvbW88Lhm26b3ud14sTBvcm1H7uWUx1Fkp/go-multiaddr-net"
-	mautp "gx/ipfs/QmYVqhVfbK4BKvbW88Lhm26b3ud14sTBvcm1H7uWUx1Fkp/go-multiaddr-net/utp"
-	utp "gx/ipfs/QmadkZhaLw1AhXKyBiPmydRuTexhj6WkiZPpo5Uks6WUVq/utp"
-	ma "gx/ipfs/QmcobAGsCjYt5DXoq9et9L8yR8er7o7Cu3DTvpaq12jYSz/go-multiaddr"
-)
-
-type FallbackDialer struct {
-	madialer manet.Dialer
-}
-
-func (fbd *FallbackDialer) Matches(a ma.Multiaddr) bool {
-	return mafmt.TCP.Matches(a) || mafmt.UTP.Matches(a)
-}
-
-func (fbd *FallbackDialer) Dial(a ma.Multiaddr) (Conn, error) {
-	if mafmt.TCP.Matches(a) {
-		return fbd.tcpDial(a)
-	}
-	if mafmt.UTP.Matches(a) {
-		return fbd.tcpDial(a)
-	}
-	return nil, fmt.Errorf("cannot dial %s with fallback dialer", a)
-}
-
-func (fbd *FallbackDialer) tcpDial(raddr ma.Multiaddr) (Conn, error) {
-	var c manet.Conn
-	var err error
-	c, err = fbd.madialer.Dial(raddr)
-
-	if err != nil {
-		return nil, err
-	}
-
-	return &connWrap{
-		Conn: c,
-	}, nil
-}
-
-func (fbd *FallbackDialer) utpDial(raddr ma.Multiaddr) (Conn, error) {
-	_, addr, err := manet.DialArgs(raddr)
-	if err != nil {
-		return nil, err
-	}
-
-	con, err := utp.Dial(addr)
-	if err != nil {
-		return nil, err
-	}
-
-	mnc, err := manet.WrapNetConn(&mautp.Conn{Conn: con})
-	if err != nil {
-		return nil, err
-	}
-
-	return &connWrap{
-		Conn: mnc,
-	}, nil
-}

p2p/net/transport/reuseport.go

-package transport
-
-import (
-	"net"
-	"os"
-	"strings"
-	"syscall"
-
-	reuseport "gx/ipfs/QmaaC9QMYTQHCbMq3Ebr3uMaAR2ev4AVqMmsJpgQijAZbJ/go-reuseport"
-)
-
-// envReuseport is the env variable name used to turn off reuse port.
-// It default to true.
-const envReuseport = "IPFS_REUSEPORT"
-
-// envReuseportVal stores the value of envReuseport. defaults to true.
-var envReuseportVal = true
-
-func init() {
-	v := strings.ToLower(os.Getenv(envReuseport))
-	if v == "false" || v == "f" || v == "0" {
-		envReuseportVal = false
-		log.Infof("REUSEPORT disabled (IPFS_REUSEPORT=%s)", v)
-	}
-}
-
-// reuseportIsAvailable returns whether reuseport is available to be used. This
-// is here because we want to be able to turn reuseport on and off selectively.
-// For now we use an ENV variable, as this handles our pressing need:
-//
-//   IPFS_REUSEPORT=false ipfs daemon
-//
-// If this becomes a sought after feature, we could add this to the config.
-// In the end, reuseport is a stop-gap.
-func ReuseportIsAvailable() bool {
-	return envReuseportVal && reuseport.Available()
-}
-
-// ReuseErrShouldRetry diagnoses whether to retry after a reuse error.
-// if we failed to bind, we should retry. if bind worked and this is a
-// real dial error (remote end didnt answer) then we should not retry.
-func ReuseErrShouldRetry(err error) bool {
-	if err == nil {
-		return false // hey, it worked! no need to retry.
-	}
-
-	// if it's a network timeout error, it's a legitimate failure.
-	if nerr, ok := err.(net.Error); ok && nerr.Timeout() {
-		return false
-	}
-
-	errno, ok := err.(syscall.Errno)
-	if !ok { // not an errno? who knows what this is. retry.
-		return true
-	}
-
-	switch errno {
-	case syscall.EADDRINUSE, syscall.EADDRNOTAVAIL:
-		return true // failure to bind. retry.
-	case syscall.ECONNREFUSED:
-		return false // real dial error
-	default:
-		return true // optimistically default to retry.
-	}
-}

p2p/net/transport/tcp.go

-package transport
-
-import (
-	"fmt"
-	"net"
-	"sync"
-	"time"
-
-	lgbl "github.com/ipfs/go-libp2p/loggables"
-	mafmt "gx/ipfs/QmWLfU4tstw2aNcTykDm44xbSTCYJ9pUJwfhQCKGwckcHx/mafmt"
-	manet "gx/ipfs/QmYVqhVfbK4BKvbW88Lhm26b3ud14sTBvcm1H7uWUx1Fkp/go-multiaddr-net"
-	context "gx/ipfs/QmZy2y8t9zQH2a1b8q2ZSLKp17ATuJoCNxxyMFG5qFExpt/go-net/context"
-	reuseport "gx/ipfs/QmaaC9QMYTQHCbMq3Ebr3uMaAR2ev4AVqMmsJpgQijAZbJ/go-reuseport"
-	ma "gx/ipfs/QmcobAGsCjYt5DXoq9et9L8yR8er7o7Cu3DTvpaq12jYSz/go-multiaddr"
-)
-
-type TcpTransport struct {
-	dlock   sync.Mutex
-	dialers map[string]Dialer
-
-	llock     sync.Mutex
-	listeners map[string]Listener
-}
-
-func NewTCPTransport() *TcpTransport {
-	return &TcpTransport{
-		dialers:   make(map[string]Dialer),
-		listeners: make(map[string]Listener),
-	}
-}
-
-func (t *TcpTransport) Dialer(laddr ma.Multiaddr, opts ...DialOpt) (Dialer, error) {
-	t.dlock.Lock()
-	defer t.dlock.Unlock()
-	s := laddr.String()
-	d, found := t.dialers[s]
-	if found {
-		return d, nil
-	}
-	var base manet.Dialer
-
-	var doReuse bool
-	for _, o := range opts {
-		switch o := o.(type) {
-		case TimeoutOpt:
-			base.Timeout = time.Duration(o)
-		case ReuseportOpt:
-			doReuse = bool(o)
-		default:
-			return nil, fmt.Errorf("unrecognized option: %#v", o)
-		}
-	}
-
-	tcpd, err := t.newTcpDialer(base, laddr, doReuse)
-	if err != nil {
-		return nil, err
-	}
-
-	t.dialers[s] = tcpd
-	return tcpd, nil
-}
-
-func (t *TcpTransport) Listen(laddr ma.Multiaddr) (Listener, error) {
-	t.llock.Lock()
-	defer t.llock.Unlock()
-	s := laddr.String()
-	l, found := t.listeners[s]
-	if found {
-		return l, nil
-	}
-
-	list, err := manetListen(laddr)
-	if err != nil {
-		return nil, err
-	}
-
-	tlist := &tcpListener{
-		list:      list,
-		transport: t,
-	}
-
-	t.listeners[s] = tlist
-	return tlist, nil
-}
-
-func manetListen(addr ma.Multiaddr) (manet.Listener, error) {
-	network, naddr, err := manet.DialArgs(addr)
-	if err != nil {
-		return nil, err
-	}
-
-	if ReuseportIsAvailable() {
-		nl, err := reuseport.Listen(network, naddr)
-		if err == nil {
-			// hey, it worked!
-			return manet.WrapNetListener(nl)
-		}
-		// reuseport is available, but we failed to listen. log debug, and retry normally.
-		log.Debugf("reuseport available, but failed to listen: %s %s, %s", network, naddr, err)
-	}
-
-	// either reuseport not available, or it failed. try normally.
-	return manet.Listen(addr)
-}
-
-func (t *TcpTransport) Matches(a ma.Multiaddr) bool {
-	return mafmt.TCP.Matches(a)
-}
-
-type tcpDialer struct {
-	laddr ma.Multiaddr
-
-	doReuse bool
-
-	rd       reuseport.Dialer
-	madialer manet.Dialer
-
-	transport Transport
-}
-
-func (t *TcpTransport) newTcpDialer(base manet.Dialer, laddr ma.Multiaddr, doReuse bool) (*tcpDialer, error) {
-	// get the local net.Addr manually
-	la, err := manet.ToNetAddr(laddr)
-	if err != nil {
-		return nil, err // something wrong with laddr.
-	}
-
-	if doReuse && ReuseportIsAvailable() {
-		rd := reuseport.Dialer{
-			D: net.Dialer{
-				LocalAddr: la,
-				Timeout:   base.Timeout,
-			},
-		}
-
-		return &tcpDialer{
-			doReuse:   true,
-			laddr:     laddr,
-			rd:        rd,
-			madialer:  base,
-			transport: t,
-		}, nil
-	}
-
-	return &tcpDialer{
-		doReuse:   false,
-		laddr:     laddr,
-		madialer:  base,
-		transport: t,
-	}, nil
-}
-
-func (d *tcpDialer) Dial(raddr ma.Multiaddr) (Conn, error) {
-	var c manet.Conn
-	var err error
-	if d.doReuse {
-		c, err = d.reuseDial(raddr)
-	} else {
-		c, err = d.madialer.Dial(raddr)
-	}
-
-	if err != nil {
-		return nil, err
-	}
-
-	return &connWrap{
-		Conn:      c,
-		transport: d.transport,
-	}, nil
-}
-
-func (d *tcpDialer) reuseDial(raddr ma.Multiaddr) (manet.Conn, error) {
-	logdial := lgbl.Dial("conn", "", "", d.laddr, raddr)
-	rpev := log.EventBegin(context.TODO(), "tptDialReusePort", logdial)
-
-	network, netraddr, err := manet.DialArgs(raddr)
-	if err != nil {
-		return nil, err
-	}
-
-	con, err := d.rd.Dial(network, netraddr)
-	if err == nil {
-		logdial["reuseport"] = "success"
-		rpev.Done()
-		return manet.WrapNetConn(con)
-	}
-
-	if !ReuseErrShouldRetry(err) {
-		logdial["reuseport"] = "failure"
-		logdial["error"] = err
-		rpev.Done()
-		return nil, err
-	}
-
-	logdial["reuseport"] = "retry"
-	logdial["error"] = err
-	rpev.Done()
-
-	return d.madialer.Dial(raddr)
-}
-
-func (d *tcpDialer) Matches(a ma.Multiaddr) bool {
-	return mafmt.TCP.Matches(a)
-}
-
-type tcpListener struct {
-	list      manet.Listener
-	transport Transport
-}
-
-func (d *tcpListener) Accept() (Conn, error) {
-	c, err := d.list.Accept()
-	if err != nil {
-		return nil, err
-	}
-
-	return &connWrap{
-		Conn:      c,
-		transport: d.transport,
-	}, nil
-}
-
-func (d *tcpListener) Addr() net.Addr {
-	return d.list.Addr()
-}
-
-func (t *tcpListener) Multiaddr() ma.Multiaddr {
-	return t.list.Multiaddr()
-}
-
-func (t *tcpListener) NetListener() net.Listener {
-	return t.list.NetListener()
-}
-
-func (d *tcpListener) Close() error {
-	return d.list.Close()
-}

p2p/net/transport/transport.go

-package transport
-
-import (
-	"net"
-	"time"
-
-	manet "gx/ipfs/QmYVqhVfbK4BKvbW88Lhm26b3ud14sTBvcm1H7uWUx1Fkp/go-multiaddr-net"
-	logging "gx/ipfs/Qmazh5oNUVsDZTs2g59rq8aYQqwpss8tcUWQzor5sCCEuH/go-log"
-	ma "gx/ipfs/QmcobAGsCjYt5DXoq9et9L8yR8er7o7Cu3DTvpaq12jYSz/go-multiaddr"
-)
-
-var log = logging.Logger("transport")
-
-type Conn interface {
-	manet.Conn
-
-	Transport() Transport
-}
-
-type Transport interface {
-	Dialer(laddr ma.Multiaddr, opts ...DialOpt) (Dialer, error)
-	Listen(laddr ma.Multiaddr) (Listener, error)
-	Matches(ma.Multiaddr) bool
-}
-
-type Dialer interface {
-	Dial(raddr ma.Multiaddr) (Conn, error)
-	Matches(ma.Multiaddr) bool
-}
-
-type Listener interface {
-	Accept() (Conn, error)
-	Close() error
-	Addr() net.Addr
-	Multiaddr() ma.Multiaddr
-}
-
-type connWrap struct {
-	manet.Conn
-	transport Transport
-}
-
-func (cw *connWrap) Transport() Transport {
-	return cw.transport
-}
-
-type DialOpt interface{}
-type TimeoutOpt time.Duration
-type ReuseportOpt bool
-
-var ReusePorts ReuseportOpt = true

p2p/net/transport/transport_test.go

-package transport
-
-import (
-	"fmt"
-	"io"
-	"testing"
-
-	ma "gx/ipfs/QmcobAGsCjYt5DXoq9et9L8yR8er7o7Cu3DTvpaq12jYSz/go-multiaddr"
-)
-
-func TestTcpTransport(t *testing.T) {
-	ta := NewTCPTransport()
-	tb := NewTCPTransport()
-
-	zero := "/ip4/127.0.0.1/tcp/0"
-	subtestTransport(t, ta, tb, zero)
-}
-
-func TestUtpTransport(t *testing.T) {
-	ta := NewUtpTransport()
-	tb := NewUtpTransport()
-
-	zero := "/ip4/127.0.0.1/udp/0/utp"
-	subtestTransport(t, ta, tb, zero)
-}
-
-func subtestTransport(t *testing.T, ta, tb Transport, addr string) {
-	maddr, err := ma.NewMultiaddr(addr)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	list, err := ta.Listen(maddr)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	dialer, err := tb.Dialer(maddr)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	accepted := make(chan Conn, 1)
-	errs := make(chan error, 1)
-	go func() {
-		b, err := list.Accept()
-		if err != nil {
-			errs <- err
-			return
-		}
-
-		accepted <- b
-	}()
-
-	a, err := dialer.Dial(list.Multiaddr())
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	var b Conn
-	select {
-	case b = <-accepted:
-	case err := <-errs:
-		t.Fatal(err)
-	}
-
-	defer a.Close()
-	defer b.Close()
-
-	err = checkDataTransfer(a, b)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-}
-
-func checkDataTransfer(a, b io.ReadWriter) error {
-	errs := make(chan error, 2)
-	data := []byte("this is some test data")
-
-	go func() {
-		n, err := a.Write(data)
-		if err != nil {
-			errs <- err
-			return
-		}
-
-		if n != len(data) {
-			errs <- fmt.Errorf("failed to write enough data (a->b)")
-			return
-		}
-
-		buf := make([]byte, len(data))
-		_, err = io.ReadFull(a, buf)
-		if err != nil {
-			errs <- err
-			return
-		}
-
-		errs <- nil
-	}()
-
-	go func() {
-		buf := make([]byte, len(data))
-		_, err := io.ReadFull(b, buf)
-		if err != nil {
-			errs <- err
-			return
-		}
-
-		n, err := b.Write(data)
-		if err != nil {
-			errs <- err
-			return
-		}
-
-		if n != len(data) {
-			errs <- fmt.Errorf("failed to write enough data (b->a)")
-			return
-		}
-
-		errs <- nil
-	}()
-
-	err := <-errs
-	if err != nil {
-		return err
-	}
-	err = <-errs
-	if err != nil {
-		return err
-	}
-
-	return nil
-}

p2p/net/transport/utp.go

-package transport
-
-import (
-	"net"
-	"sync"
-
-	mafmt "gx/ipfs/QmWLfU4tstw2aNcTykDm44xbSTCYJ9pUJwfhQCKGwckcHx/mafmt"
-	manet "gx/ipfs/QmYVqhVfbK4BKvbW88Lhm26b3ud14sTBvcm1H7uWUx1Fkp/go-multiaddr-net"
-	mautp "gx/ipfs/QmYVqhVfbK4BKvbW88Lhm26b3ud14sTBvcm1H7uWUx1Fkp/go-multiaddr-net/utp"
-	utp "gx/ipfs/QmadkZhaLw1AhXKyBiPmydRuTexhj6WkiZPpo5Uks6WUVq/utp"
-	ma "gx/ipfs/QmcobAGsCjYt5DXoq9et9L8yR8er7o7Cu3DTvpaq12jYSz/go-multiaddr"
-)
-
-type UtpTransport struct {
-	sockLock sync.Mutex
-	sockets  map[string]*UtpSocket
-}
-
-func NewUtpTransport() *UtpTransport {
-	return &UtpTransport{
-		sockets: make(map[string]*UtpSocket),
-	}
-}
-
-func (d *UtpTransport) Matches(a ma.Multiaddr) bool {
-	return mafmt.UTP.Matches(a)
-}
-
-type UtpSocket struct {
-	s         *utp.Socket
-	laddr     ma.Multiaddr
-	transport Transport
-}
-
-func (t *UtpTransport) Listen(laddr ma.Multiaddr) (Listener, error) {
-	t.sockLock.Lock()
-	defer t.sockLock.Unlock()
-	s, ok := t.sockets[laddr.String()]
-	if ok {
-		return s, nil
-	}
-
-	ns, err := t.newConn(laddr)
-	if err != nil {
-		return nil, err
-	}
-
-	t.sockets[laddr.String()] = ns
-	return ns, nil
-}
-
-func (t *UtpTransport) Dialer(laddr ma.Multiaddr, opts ...DialOpt) (Dialer, error) {
-	t.sockLock.Lock()
-	defer t.sockLock.Unlock()
-	s, ok := t.sockets[laddr.String()]
-	if ok {
-		return s, nil
-	}
-
-	ns, err := t.newConn(laddr, opts...)
-	if err != nil {
-		return nil, err
-	}
-
-	t.sockets[laddr.String()] = ns
-	return ns, nil
-}
-
-func (t *UtpTransport) newConn(addr ma.Multiaddr, opts ...DialOpt) (*UtpSocket, error) {
-	network, netaddr, err := manet.DialArgs(addr)
-	if err != nil {
-		return nil, err
-	}
-
-	s, err := utp.NewSocket("udp"+network[3:], netaddr)
-	if err != nil {
-		return nil, err
-	}
-
-	laddr, err := manet.FromNetAddr(mautp.MakeAddr(s.LocalAddr()))
-	if err != nil {
-		return nil, err
-	}
-
-	return &UtpSocket{
-		s:         s,
-		laddr:     laddr,
-		transport: t,
-	}, nil
-}
-
-func (s *UtpSocket) Dial(raddr ma.Multiaddr) (Conn, error) {
-	_, addr, err := manet.DialArgs(raddr)
-	if err != nil {
-		return nil, err
-	}
-
-	con, err := s.s.Dial(addr)
-	if err != nil {
-		return nil, err
-	}
-
-	mnc, err := manet.WrapNetConn(&mautp.Conn{Conn: con})
-	if err != nil {
-		return nil, err
-	}
-
-	return &connWrap{
-		Conn:      mnc,
-		transport: s.transport,
-	}, nil
-}
-
-func (s *UtpSocket) Accept() (Conn, error) {
-	c, err := s.s.Accept()
-	if err != nil {
-		return nil, err
-	}
-
-	mnc, err := manet.WrapNetConn(&mautp.Conn{Conn: c})
-	if err != nil {
-		return nil, err
-	}
-
-	return &connWrap{
-		Conn:      mnc,
-		transport: s.transport,
-	}, nil
-}
-
-func (s *UtpSocket) Matches(a ma.Multiaddr) bool {
-	return mafmt.UTP.Matches(a)
-}
-
-func (t *UtpSocket) Close() error {
-	return t.s.Close()
-}
-
-func (t *UtpSocket) Addr() net.Addr {
-	return t.s.Addr()
-}
-
-func (t *UtpSocket) Multiaddr() ma.Multiaddr {
-	return t.laddr
-}
-
-var _ Transport = (*UtpTransport)(nil)