mocknet: now with keys and addrs

To _really_ simulate the network, mocknet needs
to provide proper addrs and keys. Otherwise
services that depend on some of the network's
functionality (like exchanging keys) will fail oddly.

cc @maybebtc

net/mock/interface.go

@@ -10,13 +10,21 @@ import (
 	"io"
 	"time"
 
+	ic "github.com/jbenet/go-ipfs/crypto"
 	inet "github.com/jbenet/go-ipfs/net"
 	peer "github.com/jbenet/go-ipfs/peer"
+
+	ma "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr"
 )
 
 type Mocknet interface {
+
+	// GenPeer generates a peer and its inet.Network in the Mocknet
 	GenPeer() (inet.Network, error)
-	AddPeer(peer.ID) (inet.Network, error)
+
+	// AddPeer adds an existing peer. we need both a privkey and addr.
+	// ID is derived from PrivKey
+	AddPeer(ic.PrivKey, ma.Multiaddr) (inet.Network, error)
 
 	// retrieve things
 	Peers() []peer.ID

net/mock/mock_conn.go

@@ -15,8 +15,15 @@ import (
 // live connection between two peers.
 // it goes over a particular link.
 type conn struct {
-	local   peer.ID
-	remote  peer.ID
+	local  peer.ID
+	remote peer.ID
+
+	localAddr  ma.Multiaddr
+	remoteAddr ma.Multiaddr
+
+	localPrivKey ic.PrivKey
+	remotePubKey ic.PubKey
+
 	net     *peernet
 	link    *link
 	rconn   *conn // counterpart
@@ -88,7 +95,7 @@ func (c *conn) NewStreamWithProtocol(pr inet.ProtocolID) (inet.Stream, error) {
 
 // LocalMultiaddr is the Multiaddr on this side
 func (c *conn) LocalMultiaddr() ma.Multiaddr {
-	return nil
+	return c.localAddr
 }
 
 // LocalPeer is the Peer on our side of the connection
@@ -98,12 +105,12 @@ func (c *conn) LocalPeer() peer.ID {
 
 // LocalPrivateKey is the private key of the peer on our side.
 func (c *conn) LocalPrivateKey() ic.PrivKey {
-	return nil
+	return c.localPrivKey
 }
 
 // RemoteMultiaddr is the Multiaddr on the remote side
 func (c *conn) RemoteMultiaddr() ma.Multiaddr {
-	return nil
+	return c.remoteAddr
 }
 
 // RemotePeer is the Peer on the remote side
@@ -113,5 +120,5 @@ func (c *conn) RemotePeer() peer.ID {
 
 // RemotePublicKey is the private key of the peer on our side.
 func (c *conn) RemotePublicKey() ic.PubKey {
-	return nil
+	return c.remotePubKey
 }

net/mock/mock_link.go

@@ -15,6 +15,8 @@ type link struct {
 	nets []*peernet
 	opts LinkOptions
 
+	// this could have addresses on both sides.
+
 	sync.RWMutex
 }
 
@@ -26,15 +28,22 @@ func (l *link) newConnPair(dialer *peernet) (*conn, *conn) {
 	l.RLock()
 	defer l.RUnlock()
 
-	mkconn := func(n *peernet, rid peer.ID) *conn {
-		c := &conn{net: n, link: l}
-		c.local = n.peer
-		c.remote = rid
+	mkconn := func(ln, rn *peernet) *conn {
+		c := &conn{net: ln, link: l}
+		c.local = ln.peer
+		c.remote = rn.peer
+
+		c.localAddr = ln.ps.Addresses(ln.peer)[0]
+		c.remoteAddr = rn.ps.Addresses(rn.peer)[0]
+
+		c.localPrivKey = ln.ps.PrivKey(ln.peer)
+		c.remotePubKey = rn.ps.PubKey(rn.peer)
+
 		return c
 	}
 
-	c1 := mkconn(l.nets[0], l.nets[1].peer)
-	c2 := mkconn(l.nets[1], l.nets[0].peer)
+	c1 := mkconn(l.nets[0], l.nets[1])
+	c2 := mkconn(l.nets[1], l.nets[0])
 	c1.rconn = c2
 	c2.rconn = c1
 

net/mock/mock_net.go

@@ -4,12 +4,14 @@ import (
 	"fmt"
 	"sync"
 
+	ic "github.com/jbenet/go-ipfs/crypto"
 	inet "github.com/jbenet/go-ipfs/net"
 	peer "github.com/jbenet/go-ipfs/peer"
 	testutil "github.com/jbenet/go-ipfs/util/testutil"
 
 	context "github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/go.net/context"
 	ctxgroup "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-ctxgroup"
+	ma "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr"
 )
 
 // mocknet implements mocknet.Mocknet
@@ -39,12 +41,14 @@ func New(ctx context.Context) Mocknet {
 }
 
 func (mn *mocknet) GenPeer() (inet.Network, error) {
-	p, err := testutil.RandPeerID()
+	sk, _, err := testutil.RandKeyPair(512)
 	if err != nil {
 		return nil, err
 	}
 
-	n, err := mn.AddPeer(p)
+	a := testutil.RandLocalTCPAddress()
+
+	n, err := mn.AddPeer(sk, a)
 	if err != nil {
 		return nil, err
 	}
@@ -52,8 +56,8 @@ func (mn *mocknet) GenPeer() (inet.Network, error) {
 	return n, nil
 }
 
-func (mn *mocknet) AddPeer(p peer.ID) (inet.Network, error) {
-	n, err := newPeernet(mn.cg.Context(), mn, p)
+func (mn *mocknet) AddPeer(k ic.PrivKey, a ma.Multiaddr) (inet.Network, error) {
+	n, err := newPeernet(mn.cg.Context(), mn, k, a)
 	if err != nil {
 		return nil, err
 	}

net/mock/mock_peernet.go

@@ -5,6 +5,7 @@ import (
 	"math/rand"
 	"sync"
 
+	ic "github.com/jbenet/go-ipfs/crypto"
 	inet "github.com/jbenet/go-ipfs/net"
 	peer "github.com/jbenet/go-ipfs/peer"
 
@@ -34,10 +35,19 @@ type peernet struct {
 }
 
 // newPeernet constructs a new peernet
-func newPeernet(ctx context.Context, m *mocknet, p peer.ID) (*peernet, error) {
+func newPeernet(ctx context.Context, m *mocknet, k ic.PrivKey,
+	a ma.Multiaddr) (*peernet, error) {
+
+	p, err := peer.IDFromPublicKey(k.GetPublic())
+	if err != nil {
+		return nil, err
+	}
 
 	// create our own entirely, so that peers knowledge doesn't get shared
 	ps := peer.NewPeerstore()
+	ps.AddAddress(p, a)
+	ps.AddPrivKey(p, k)
+	ps.AddPubKey(p, k.GetPublic())
 
 	n := &peernet{
 		mocknet: m,