reworked Conn

net/conn/conn_test.go

@@ -3,98 +3,114 @@ package conn
 import (
 	"testing"
 
+	ci "github.com/jbenet/go-ipfs/crypto"
+	msg "github.com/jbenet/go-ipfs/net/message"
 	peer "github.com/jbenet/go-ipfs/peer"
 
+	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"
-	manet "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr/net"
-	mh "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multihash"
 )
 
-func setupPeer(id string, addr string) (*peer.Peer, error) {
+func setupPeer(addr string) (*peer.Peer, error) {
 	tcp, err := ma.NewMultiaddr(addr)
 	if err != nil {
 		return nil, err
 	}
 
-	mh, err := mh.FromHexString(id)
+	sk, pk, err := ci.GenerateKeyPair(ci.RSA, 512)
 	if err != nil {
 		return nil, err
 	}
 
-	p := &peer.Peer{ID: peer.ID(mh)}
+	id, err := peer.IDFromPubKey(pk)
+	if err != nil {
+		return nil, err
+	}
+
+	p := &peer.Peer{ID: id}
+	p.PrivKey = sk
+	p.PubKey = pk
 	p.AddAddress(tcp)
 	return p, nil
 }
 
-func echoListen(listener manet.Listener) {
+func echoListen(ctx context.Context, listener Listener) {
 	for {
-		c, err := listener.Accept()
-		if err == nil {
-			// fmt.Println("accepeted")
-			go echo(c)
+		select {
+		case <-ctx.Done():
+			return
+		case c := <-listener.Accept():
+			go echo(ctx, c)
 		}
 	}
 }
 
-func echo(c manet.Conn) {
+func echo(ctx context.Context, c Conn) {
 	for {
-		data := make([]byte, 1024)
-		i, err := c.Read(data)
-		if err != nil {
-			// fmt.Printf("error %v\n", err)
+		select {
+		case <-ctx.Done():
 			return
+		case m := <-c.MsgIn():
+			c.MsgOut() <- m
 		}
-		_, err = c.Write(data[:i])
-		if err != nil {
-			// fmt.Printf("error %v\n", err)
-			return
-		}
-		// fmt.Println("echoing", data[:i])
 	}
 }
 
-func TestDial(t *testing.T) {
+func TestDialer(t *testing.T) {
 
-	maddr, err := ma.NewMultiaddr("/ip4/127.0.0.1/tcp/1234")
-	if err != nil {
-		t.Fatal("failure to parse multiaddr")
-	}
-	listener, err := manet.Listen(maddr)
+	p1, err := setupPeer("/ip4/127.0.0.1/tcp/1234")
 	if err != nil {
-		t.Fatal("error setting up listener", err)
+		t.Fatal("error setting up peer", err)
 	}
-	go echoListen(listener)
 
-	p1, err := setupPeer("11140beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33", "/ip4/127.0.0.1/tcp/1234")
+	p2, err := setupPeer("/ip4/127.0.0.1/tcp/3456")
 	if err != nil {
 		t.Fatal("error setting up peer", err)
 	}
 
-	p2, err := setupPeer("11140beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a34", "/ip4/127.0.0.1/tcp/3456")
+	ctx, cancel := context.WithCancel(context.Background())
+
+	laddr := p1.NetAddress("tcp")
+	if laddr == nil {
+		t.Fatal("Listen address is nil.")
+	}
+
+	l, err := Listen(ctx, laddr, p1, peer.NewPeerstore())
 	if err != nil {
-		t.Fatal("error setting up peer", err)
+		t.Fatal(err)
 	}
 
-	c, err := Dial("tcp", p2, p1)
+	go echoListen(ctx, l)
+
+	d := &Dialer{
+		Peerstore: peer.NewPeerstore(),
+		LocalPeer: p2,
+	}
+
+	c, err := d.Dial(ctx, "tcp", p1)
 	if err != nil {
 		t.Fatal("error dialing peer", err)
 	}
 
 	// fmt.Println("sending")
-	c.Outgoing.MsgChan <- []byte("beep")
-	c.Outgoing.MsgChan <- []byte("boop")
-	out := <-c.Incoming.MsgChan
+	c.MsgOut() <- msg.New(p2, []byte("beep"))
+	c.MsgOut() <- msg.New(p2, []byte("boop"))
+
+	out := <-c.MsgIn()
 	// fmt.Println("recving", string(out))
-	if string(out) != "beep" {
-		t.Error("unexpected conn output")
+	data := string(out.Data())
+	if data != "beep" {
+		t.Error("unexpected conn output", data)
 	}
 
-	out = <-c.Incoming.MsgChan
-	if string(out) != "boop" {
-		t.Error("unexpected conn output")
+	out = <-c.MsgIn()
+	data = string(out.Data())
+	if string(out.Data()) != "boop" {
+		t.Error("unexpected conn output", data)
 	}
 
 	// fmt.Println("closing")
 	c.Close()
-	listener.Close()
+	l.Close()
+	cancel()
 }

net/conn/interface.go

+package conn
+
+import (
+	msg "github.com/jbenet/go-ipfs/net/message"
+	peer "github.com/jbenet/go-ipfs/peer"
+
+	ma "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr"
+)
+
+// Conn is a generic message-based Peer-to-Peer connection.
+type Conn interface {
+
+	// LocalPeer is the Peer on this side
+	LocalPeer() *peer.Peer
+
+	// RemotePeer is the Peer on the remote side
+	RemotePeer() *peer.Peer
+
+	// MsgIn returns a readable message channel
+	MsgIn() <-chan msg.NetMessage
+
+	// MsgOut returns a writable message channel
+	MsgOut() chan<- msg.NetMessage
+
+	// Close ends the connection
+	Close() error
+}
+
+// Listener is an object that can accept connections. It matches net.Listener
+type Listener interface {
+
+	// Accept waits for and returns the next connection to the listener.
+	Accept() <-chan Conn
+
+	// Multiaddr is the identity of the local Peer.
+	Multiaddr() ma.Multiaddr
+
+	// LocalPeer is the identity of the local Peer.
+	LocalPeer() *peer.Peer
+
+	// Peerstore is the set of peers we know about locally. The Listener needs it
+	// because when an incoming connection is identified, we should reuse the
+	// same peer objects (otherwise things get inconsistent).
+	Peerstore() peer.Peerstore
+
+	// Close closes the listener.
+	// Any blocked Accept operations will be unblocked and return errors.
+	Close() error
+}