swap net2 -> net

net2/swarm/swarm_listen.go

-package swarm
-
-import (
-	conn "github.com/jbenet/go-ipfs/p2p/net/conn"
-	lgbl "github.com/jbenet/go-ipfs/util/eventlog/loggables"
-
-	context "github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/go.net/context"
-	ma "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr"
-	ps "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-peerstream"
-	multierr "github.com/jbenet/go-ipfs/util/multierr"
-)
-
-// Open listeners for each network the swarm should listen on
-func (s *Swarm) listen(addrs []ma.Multiaddr) error {
-	retErr := multierr.New()
-
-	// listen on every address
-	for i, addr := range addrs {
-		err := s.setupListener(addr)
-		if err != nil {
-			if retErr.Errors == nil {
-				retErr.Errors = make([]error, len(addrs))
-			}
-			retErr.Errors[i] = err
-			log.Errorf("Failed to listen on: %s - %s", addr, err)
-		}
-	}
-
-	if retErr.Errors != nil {
-		return retErr
-	}
-	return nil
-}
-
-// Listen for new connections on the given multiaddr
-func (s *Swarm) setupListener(maddr ma.Multiaddr) error {
-
-	// TODO rethink how this has to work. (jbenet)
-	//
-	// resolved, err := resolveUnspecifiedAddresses([]ma.Multiaddr{maddr})
-	// if err != nil {
-	// 	return err
-	// }
-	// for _, a := range resolved {
-	// 	s.peers.AddAddress(s.local, a)
-	// }
-
-	sk := s.peers.PrivKey(s.local)
-	if sk == nil {
-		// may be fine for sk to be nil, just log a warning.
-		log.Warning("Listener not given PrivateKey, so WILL NOT SECURE conns.")
-	}
-	list, err := conn.Listen(s.cg.Context(), maddr, s.local, sk)
-	if err != nil {
-		return err
-	}
-
-	// AddListener to the peerstream Listener. this will begin accepting connections
-	// and streams!
-	_, err = s.swarm.AddListener(list)
-	return err
-}
-
-// connHandler is called by the StreamSwarm whenever a new connection is added
-// here we configure it slightly. Note that this is sequential, so if anything
-// will take a while do it in a goroutine.
-// See https://godoc.org/github.com/jbenet/go-peerstream for more information
-func (s *Swarm) connHandler(c *ps.Conn) *Conn {
-	ctx := context.Background()
-	// this context is for running the handshake, which -- when receiveing connections
-	// -- we have no bound on beyond what the transport protocol bounds it at.
-	// note that setup + the handshake are bounded by underlying io.
-	// (i.e. if TCP or UDP disconnects (or the swarm closes), we're done.
-	// Q: why not have a shorter handshake? think about an HTTP server on really slow conns.
-	// as long as the conn is live (TCP says its online), it tries its best. we follow suit.)
-
-	sc, err := s.newConnSetup(ctx, c)
-	if err != nil {
-		log.Error(err)
-		log.Event(ctx, "newConnHandlerDisconnect", lgbl.NetConn(c.NetConn()), lgbl.Error(err))
-		c.Close() // boom. close it.
-		return nil
-	}
-
-	return sc
-}

net2/swarm/swarm_stream.go

-package swarm
-
-import (
-	inet "github.com/jbenet/go-ipfs/p2p/net2"
-
-	ps "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-peerstream"
-)
-
-// a Stream is a wrapper around a ps.Stream that exposes a way to get
-// our Conn and Swarm (instead of just the ps.Conn and ps.Swarm)
-type Stream ps.Stream
-
-// Stream returns the underlying peerstream.Stream
-func (s *Stream) Stream() *ps.Stream {
-	return (*ps.Stream)(s)
-}
-
-// Conn returns the Conn associated with this Stream, as an inet.Conn
-func (s *Stream) Conn() inet.Conn {
-	return s.SwarmConn()
-}
-
-// SwarmConn returns the Conn associated with this Stream, as a *Conn
-func (s *Stream) SwarmConn() *Conn {
-	return (*Conn)(s.Stream().Conn())
-}
-
-// Wait waits for the stream to receive a reply.
-func (s *Stream) Wait() error {
-	return s.Stream().Wait()
-}
-
-// Read reads bytes from a stream.
-func (s *Stream) Read(p []byte) (n int, err error) {
-	return s.Stream().Read(p)
-}
-
-// Write writes bytes to a stream, flushing for each call.
-func (s *Stream) Write(p []byte) (n int, err error) {
-	return s.Stream().Write(p)
-}
-
-// Close closes the stream, indicating this side is finished
-// with the stream.
-func (s *Stream) Close() error {
-	return s.Stream().Close()
-}
-
-func wrapStream(pss *ps.Stream) *Stream {
-	return (*Stream)(pss)
-}
-
-func wrapStreams(st []*ps.Stream) []*Stream {
-	out := make([]*Stream, len(st))
-	for i, s := range st {
-		out[i] = wrapStream(s)
-	}
-	return out
-}

net2/swarm/swarm_test.go

-package swarm
-
-import (
-	"bytes"
-	"io"
-	"sync"
-	"testing"
-	"time"
-
-	inet "github.com/jbenet/go-ipfs/p2p/net2"
-	peer "github.com/jbenet/go-ipfs/p2p/peer"
-	errors "github.com/jbenet/go-ipfs/util/debugerror"
-	testutil "github.com/jbenet/go-ipfs/util/testutil"
-
-	context "github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/go.net/context"
-	ma "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr"
-)
-
-func EchoStreamHandler(stream inet.Stream) {
-	go func() {
-		defer stream.Close()
-
-		// pull out the ipfs conn
-		c := stream.Conn()
-		log.Debugf("%s ponging to %s", c.LocalPeer(), c.RemotePeer())
-
-		buf := make([]byte, 4)
-
-		for {
-			if _, err := stream.Read(buf); err != nil {
-				if err != io.EOF {
-					log.Error("ping receive error:", err)
-				}
-				return
-			}
-
-			if !bytes.Equal(buf, []byte("ping")) {
-				log.Errorf("ping receive error: ping != %s %v", buf, buf)
-				return
-			}
-
-			if _, err := stream.Write([]byte("pong")); err != nil {
-				log.Error("pond send error:", err)
-				return
-			}
-		}
-	}()
-}
-
-func makeSwarms(ctx context.Context, t *testing.T, num int) ([]*Swarm, []testutil.PeerNetParams) {
-	swarms := make([]*Swarm, 0, num)
-	peersnp := make([]testutil.PeerNetParams, 0, num)
-
-	for i := 0; i < num; i++ {
-		localnp := testutil.RandPeerNetParamsOrFatal(t)
-		peersnp = append(peersnp, localnp)
-
-		peerstore := peer.NewPeerstore()
-		peerstore.AddAddress(localnp.ID, localnp.Addr)
-		peerstore.AddPubKey(localnp.ID, localnp.PubKey)
-		peerstore.AddPrivKey(localnp.ID, localnp.PrivKey)
-
-		addrs := peerstore.Addresses(localnp.ID)
-		swarm, err := NewSwarm(ctx, addrs, localnp.ID, peerstore)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		swarm.SetStreamHandler(EchoStreamHandler)
-		swarms = append(swarms, swarm)
-	}
-
-	return swarms, peersnp
-}
-
-func connectSwarms(t *testing.T, ctx context.Context, swarms []*Swarm, peersnp []testutil.PeerNetParams) {
-
-	var wg sync.WaitGroup
-	connect := func(s *Swarm, dst peer.ID, addr ma.Multiaddr) {
-		// TODO: make a DialAddr func.
-		s.peers.AddAddress(dst, addr)
-		if _, err := s.Dial(ctx, dst); err != nil {
-			t.Fatal("error swarm dialing to peer", err)
-		}
-		wg.Done()
-	}
-
-	log.Info("Connecting swarms simultaneously.")
-	for _, s := range swarms {
-		for _, p := range peersnp {
-			if p.ID != s.local { // don't connect to self.
-				wg.Add(1)
-				connect(s, p.ID, p.Addr)
-			}
-		}
-	}
-	wg.Wait()
-
-	for _, s := range swarms {
-		log.Infof("%s swarm routing table: %s", s.local, s.Peers())
-	}
-}
-
-func SubtestSwarm(t *testing.T, SwarmNum int, MsgNum int) {
-	// t.Skip("skipping for another test")
-
-	ctx := context.Background()
-	swarms, peersnp := makeSwarms(ctx, t, SwarmNum)
-
-	// connect everyone
-	connectSwarms(t, ctx, swarms, peersnp)
-
-	// ping/pong
-	for _, s1 := range swarms {
-		log.Debugf("-------------------------------------------------------")
-		log.Debugf("%s ping pong round", s1.local)
-		log.Debugf("-------------------------------------------------------")
-
-		_, cancel := context.WithCancel(ctx)
-		got := map[peer.ID]int{}
-		errChan := make(chan error, MsgNum*len(peersnp))
-		streamChan := make(chan *Stream, MsgNum)
-
-		// send out "ping" x MsgNum to every peer
-		go func() {
-			defer close(streamChan)
-
-			var wg sync.WaitGroup
-			send := func(p peer.ID) {
-				defer wg.Done()
-
-				// first, one stream per peer (nice)
-				stream, err := s1.NewStreamWithPeer(p)
-				if err != nil {
-					errChan <- errors.Wrap(err)
-					return
-				}
-
-				// send out ping!
-				for k := 0; k < MsgNum; k++ { // with k messages
-					msg := "ping"
-					log.Debugf("%s %s %s (%d)", s1.local, msg, p, k)
-					stream.Write([]byte(msg))
-				}
-
-				// read it later
-				streamChan <- stream
-			}
-
-			for _, p := range peersnp {
-				if p.ID == s1.local {
-					continue // dont send to self...
-				}
-
-				wg.Add(1)
-				go send(p.ID)
-			}
-			wg.Wait()
-		}()
-
-		// receive "pong" x MsgNum from every peer
-		go func() {
-			defer close(errChan)
-			count := 0
-			countShouldBe := MsgNum * (len(peersnp) - 1)
-			for stream := range streamChan { // one per peer
-				defer stream.Close()
-
-				// get peer on the other side
-				p := stream.Conn().RemotePeer()
-
-				// receive pings
-				msgCount := 0
-				msg := make([]byte, 4)
-				for k := 0; k < MsgNum; k++ { // with k messages
-
-					// read from the stream
-					if _, err := stream.Read(msg); err != nil {
-						errChan <- errors.Wrap(err)
-						continue
-					}
-
-					if string(msg) != "pong" {
-						errChan <- errors.Errorf("unexpected message: %s", msg)
-						continue
-					}
-
-					log.Debugf("%s %s %s (%d)", s1.local, msg, p, k)
-					msgCount++
-				}
-
-				got[p] = msgCount
-				count += msgCount
-			}
-
-			if count != countShouldBe {
-				errChan <- errors.Errorf("count mismatch: %d != %d", count, countShouldBe)
-			}
-		}()
-
-		// check any errors (blocks till consumer is done)
-		for err := range errChan {
-			if err != nil {
-				t.Fatal(err.Error())
-			}
-		}
-
-		log.Debugf("%s got pongs", s1.local)
-		if (len(peersnp) - 1) != len(got) {
-			t.Errorf("got (%d) less messages than sent (%d).", len(got), len(peersnp))
-		}
-
-		for p, n := range got {
-			if n != MsgNum {
-				t.Error("peer did not get all msgs", p, n, "/", MsgNum)
-			}
-		}
-
-		cancel()
-		<-time.After(10 * time.Millisecond)
-	}
-
-	for _, s := range swarms {
-		s.Close()
-	}
-}
-
-func TestSwarm(t *testing.T) {
-	// t.Skip("skipping for another test")
-
-	// msgs := 1000
-	msgs := 100
-	swarms := 5
-	SubtestSwarm(t, swarms, msgs)
-}
-
-func TestConnHandler(t *testing.T) {
-	// t.Skip("skipping for another test")
-
-	ctx := context.Background()
-	swarms, peersnp := makeSwarms(ctx, t, 5)
-
-	gotconn := make(chan struct{}, 10)
-	swarms[0].SetConnHandler(func(conn *Conn) {
-		gotconn <- struct{}{}
-	})
-
-	connectSwarms(t, ctx, swarms, peersnp)
-
-	<-time.After(time.Millisecond)
-	// should've gotten 5 by now.
-
-	swarms[0].SetConnHandler(nil)
-
-	expect := 4
-	for i := 0; i < expect; i++ {
-		select {
-		case <-time.After(time.Second):
-			t.Fatal("failed to get connections")
-		case <-gotconn:
-		}
-	}
-
-	select {
-	case <-gotconn:
-		t.Fatalf("should have connected to %d swarms", expect)
-	default:
-	}
-}

protocol/identify/id.go

@@ -13,7 +13,7 @@ import (
 	eventlog "github.com/jbenet/go-ipfs/util/eventlog"
 
 	host "github.com/jbenet/go-ipfs/p2p/host"
-	inet "github.com/jbenet/go-ipfs/p2p/net2"
+	inet "github.com/jbenet/go-ipfs/p2p/net"
 	protocol "github.com/jbenet/go-ipfs/p2p/protocol"
 
 	pb "github.com/jbenet/go-ipfs/p2p/protocol/identify/pb"

protocol/mux.go

@@ -7,7 +7,7 @@ import (
 
 	context "github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/go.net/context"
 
-	inet "github.com/jbenet/go-ipfs/p2p/net2"
+	inet "github.com/jbenet/go-ipfs/p2p/net"
 	eventlog "github.com/jbenet/go-ipfs/util/eventlog"
 	lgbl "github.com/jbenet/go-ipfs/util/eventlog/loggables"
 )

protocol/mux_test.go

@@ -4,7 +4,7 @@ import (
 	"bytes"
 	"testing"
 
-	inet "github.com/jbenet/go-ipfs/p2p/net2"
+	inet "github.com/jbenet/go-ipfs/p2p/net"
 )
 
 var testCases = map[string]string{

protocol/relay/relay.go

@@ -7,7 +7,7 @@ import (
 	mh "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multihash"
 
 	host "github.com/jbenet/go-ipfs/p2p/host"
-	inet "github.com/jbenet/go-ipfs/p2p/net2"
+	inet "github.com/jbenet/go-ipfs/p2p/net"
 	peer "github.com/jbenet/go-ipfs/p2p/peer"
 	protocol "github.com/jbenet/go-ipfs/p2p/protocol"
 	eventlog "github.com/jbenet/go-ipfs/util/eventlog"

protocol/relay/relay_test.go

@@ -4,7 +4,7 @@ import (
 	"io"
 	"testing"
 
-	inet "github.com/jbenet/go-ipfs/p2p/net2"
+	inet "github.com/jbenet/go-ipfs/p2p/net"
 	protocol "github.com/jbenet/go-ipfs/p2p/protocol"
 	relay "github.com/jbenet/go-ipfs/p2p/protocol/relay"
 	testutil "github.com/jbenet/go-ipfs/p2p/test/util"

test/backpressure/backpressure_test.go

@@ -8,7 +8,7 @@ import (
 	"time"
 
 	host "github.com/jbenet/go-ipfs/p2p/host"
-	inet "github.com/jbenet/go-ipfs/p2p/net2"
+	inet "github.com/jbenet/go-ipfs/p2p/net"
 	peer "github.com/jbenet/go-ipfs/p2p/peer"
 	protocol "github.com/jbenet/go-ipfs/p2p/protocol"
 	testutil "github.com/jbenet/go-ipfs/p2p/test/util"

test/util/util.go

@@ -4,8 +4,8 @@ import (
 	"testing"
 
 	bhost "github.com/jbenet/go-ipfs/p2p/host/basic"
-	inet "github.com/jbenet/go-ipfs/p2p/net2"
-	swarm "github.com/jbenet/go-ipfs/p2p/net2/swarm"
+	inet "github.com/jbenet/go-ipfs/p2p/net"
+	swarm "github.com/jbenet/go-ipfs/p2p/net/swarm"
 	peer "github.com/jbenet/go-ipfs/p2p/peer"
 	tu "github.com/jbenet/go-ipfs/util/testutil"