refactor(peer) some _minor_ safety features

blocks/blockstore/write_cache_test.go

@@ -1,10 +1,11 @@
 package blockstore
 
 import (
+	"testing"
+
 	ds "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-datastore"
 	syncds "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-datastore/sync"
 	"github.com/jbenet/go-ipfs/blocks"
-	"testing"
 )
 
 func TestReturnsErrorWhenSizeNegative(t *testing.T) {

core/commands/swarm.go

@@ -149,8 +149,12 @@ func splitAddresses(addrs []string) (maddrs []ma.Multiaddr, pids []peer.ID, err
 		if err != nil {
 			return nil, nil, cmds.ClientError("invalid peer address: " + err.Error())
 		}
+		id, err := peer.DecodePrettyID(path.Base(addr))
+		if err != nil {
+			return nil, nil, err
+		}
+		pids[i] = id
 		maddrs[i] = a
-		pids[i] = peer.DecodePrettyID(path.Base(addr))
 	}
 	return
 }
@@ -165,7 +169,7 @@ func peersWithAddresses(ps peer.Peerstore, addrs []string) ([]peer.Peer, error)
 
 	peers := make([]peer.Peer, len(pids))
 	for i, pid := range pids {
-		p, err := ps.Get(pid)
+		p, err := ps.FindOrCreate(pid)
 		if err != nil {
 			return nil, err
 		}

core/core.go

@@ -223,7 +223,7 @@ func initIdentity(cfg *config.Identity, peers peer.Peerstore, online bool) (peer
 
 	// get peer from peerstore (so it is constructed there)
 	id := peer.ID(b58.Decode(cfg.PeerID))
-	self, err := peers.Get(id)
+	self, err := peers.FindOrCreate(id)
 	if err != nil {
 		return nil, err
 	}
@@ -265,7 +265,12 @@ func initConnections(ctx context.Context, cfg *config.Config, pstore peer.Peerst
 		}
 
 		// setup peer
-		npeer, err := pstore.Get(peer.DecodePrettyID(p.PeerID))
+		id, err := peer.DecodePrettyID(p.PeerID)
+		if err != nil {
+			log.Criticalf("Bootstrapping error: %v", err)
+			continue
+		}
+		npeer, err := pstore.FindOrCreate(id)
 		if err != nil {
 			log.Criticalf("Bootstrapping error: %v", err)
 			continue

core/mock.go

@@ -25,12 +25,13 @@ func NewMockNode() (*IpfsNode, error) {
 		return nil, err
 	}
 
-	p, err := peer.WithKeyPair(sk, pk)
+	nd.Peerstore = peer.NewPeerstore()
+
+	p, err := nd.Peerstore.WithKeyPair(sk, pk)
 	if err != nil {
 		return nil, err
 	}
 
-	nd.Peerstore = peer.NewPeerstore()
 	nd.Identity, err = nd.Peerstore.Add(p)
 	if err != nil {
 		return nil, err

crypto/spipe/handshake.go

@@ -14,9 +14,10 @@ import (
 	"crypto/sha1"
 	"crypto/sha256"
 	"crypto/sha512"
-	bfish "github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/go.crypto/blowfish"
 	"hash"
 
+	bfish "github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/go.crypto/blowfish"
+
 	proto "github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/goprotobuf/proto"
 
 	ci "github.com/jbenet/go-ipfs/crypto"
@@ -368,7 +369,7 @@ func getOrConstructPeer(peers peer.Peerstore, rpk ci.PubKey) (peer.Peer, error)
 		return nil, err
 	}
 
-	npeer, err := peers.Get(rid)
+	npeer, err := peers.FindOrCreate(rid)
 	if err != nil {
 		return nil, err // unexpected error happened.
 	}

crypto/spipe/spipe_test.go

@@ -9,6 +9,7 @@ import (
 	"github.com/jbenet/go-ipfs/peer"
 	"github.com/jbenet/go-ipfs/util"
 	"github.com/jbenet/go-ipfs/util/pipes"
+	testutil "github.com/jbenet/go-ipfs/util/testutil"
 )
 
 func getPeer(tb testing.TB) peer.Peer {
@@ -17,7 +18,7 @@ func getPeer(tb testing.TB) peer.Peer {
 		tb.Fatal(err)
 	}
 
-	p, err := peer.WithKeyPair(privk, pubk)
+	p, err := testutil.NewPeerWithKeyPair(privk, pubk)
 	if err != nil {
 		tb.Fatal(err)
 	}

exchange/bitswap/bitswap_test.go

@@ -10,8 +10,8 @@ import (
 	blocks "github.com/jbenet/go-ipfs/blocks"
 	blocksutil "github.com/jbenet/go-ipfs/blocks/blocksutil"
 	tn "github.com/jbenet/go-ipfs/exchange/bitswap/testnet"
-	peer "github.com/jbenet/go-ipfs/peer"
 	mock "github.com/jbenet/go-ipfs/routing/mock"
+	testutil "github.com/jbenet/go-ipfs/util/testutil"
 )
 
 func TestClose(t *testing.T) {
@@ -53,7 +53,7 @@ func TestProviderForKeyButNetworkCannotFind(t *testing.T) {
 	g := NewSessionGenerator(net, rs)
 
 	block := blocks.NewBlock([]byte("block"))
-	rs.Announce(peer.WithIDString("testing"), block.Key()) // but not on network
+	rs.Announce(testutil.NewPeerWithIDString("testing"), block.Key()) // but not on network
 
 	solo := g.Next()
 

exchange/bitswap/message/message_test.go

@@ -6,8 +6,8 @@ import (
 
 	blocks "github.com/jbenet/go-ipfs/blocks"
 	pb "github.com/jbenet/go-ipfs/exchange/bitswap/message/internal/pb"
-	peer "github.com/jbenet/go-ipfs/peer"
 	u "github.com/jbenet/go-ipfs/util"
+	testutil "github.com/jbenet/go-ipfs/util/testutil"
 )
 
 func TestAppendWanted(t *testing.T) {
@@ -89,7 +89,7 @@ func TestCopyProtoByValue(t *testing.T) {
 
 func TestToNetMethodSetsPeer(t *testing.T) {
 	m := New()
-	p := peer.WithIDString("X")
+	p := testutil.NewPeerWithIDString("X")
 	netmsg, err := m.ToNet(p)
 	if err != nil {
 		t.Fatal(err)
@@ -107,7 +107,7 @@ func TestToNetFromNetPreservesWantList(t *testing.T) {
 	original.AddWanted(u.Key("T"))
 	original.AddWanted(u.Key("F"))
 
-	p := peer.WithIDString("X")
+	p := testutil.NewPeerWithIDString("X")
 	netmsg, err := original.ToNet(p)
 	if err != nil {
 		t.Fatal(err)
@@ -138,7 +138,7 @@ func TestToAndFromNetMessage(t *testing.T) {
 	original.AddBlock(blocks.NewBlock([]byte("F")))
 	original.AddBlock(blocks.NewBlock([]byte("M")))
 
-	p := peer.WithIDString("X")
+	p := testutil.NewPeerWithIDString("X")
 	netmsg, err := original.ToNet(p)
 	if err != nil {
 		t.Fatal(err)

exchange/bitswap/strategy/strategy_test.go

@@ -7,6 +7,7 @@ import (
 	blocks "github.com/jbenet/go-ipfs/blocks"
 	message "github.com/jbenet/go-ipfs/exchange/bitswap/message"
 	peer "github.com/jbenet/go-ipfs/peer"
+	testutil "github.com/jbenet/go-ipfs/util/testutil"
 )
 
 type peerAndStrategist struct {
@@ -16,7 +17,7 @@ type peerAndStrategist struct {
 
 func newPeerAndStrategist(idStr string) peerAndStrategist {
 	return peerAndStrategist{
-		Peer:     peer.WithIDString(idStr),
+		Peer:     testutil.NewPeerWithIDString(idStr),
 		Strategy: New(true),
 	}
 }

exchange/bitswap/testnet/network_test.go

@@ -9,6 +9,7 @@ import (
 	bsmsg "github.com/jbenet/go-ipfs/exchange/bitswap/message"
 	bsnet "github.com/jbenet/go-ipfs/exchange/bitswap/network"
 	peer "github.com/jbenet/go-ipfs/peer"
+	testutil "github.com/jbenet/go-ipfs/util/testutil"
 )
 
 func TestSendRequestToCooperativePeer(t *testing.T) {
@@ -18,8 +19,8 @@ func TestSendRequestToCooperativePeer(t *testing.T) {
 
 	t.Log("Get two network adapters")
 
-	initiator := net.Adapter(peer.WithIDString("initiator"))
-	recipient := net.Adapter(peer.WithID(idOfRecipient))
+	initiator := net.Adapter(testutil.NewPeerWithIDString("initiator"))
+	recipient := net.Adapter(testutil.NewPeerWithID(idOfRecipient))
 
 	expectedStr := "response from recipient"
 	recipient.SetDelegate(lambda(func(
@@ -43,7 +44,7 @@ func TestSendRequestToCooperativePeer(t *testing.T) {
 	message := bsmsg.New()
 	message.AddBlock(blocks.NewBlock([]byte("data")))
 	response, err := initiator.SendRequest(
-		context.Background(), peer.WithID(idOfRecipient), message)
+		context.Background(), testutil.NewPeerWithID(idOfRecipient), message)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -61,8 +62,8 @@ func TestSendRequestToCooperativePeer(t *testing.T) {
 func TestSendMessageAsyncButWaitForResponse(t *testing.T) {
 	net := VirtualNetwork()
 	idOfResponder := []byte("responder")
-	waiter := net.Adapter(peer.WithIDString("waiter"))
-	responder := net.Adapter(peer.WithID(idOfResponder))
+	waiter := net.Adapter(testutil.NewPeerWithIDString("waiter"))
+	responder := net.Adapter(testutil.NewPeerWithID(idOfResponder))
 
 	var wg sync.WaitGroup
 
@@ -107,7 +108,7 @@ func TestSendMessageAsyncButWaitForResponse(t *testing.T) {
 	messageSentAsync := bsmsg.New()
 	messageSentAsync.AddBlock(blocks.NewBlock([]byte("data")))
 	errSending := waiter.SendMessage(
-		context.Background(), peer.WithID(idOfResponder), messageSentAsync)
+		context.Background(), testutil.NewPeerWithID(idOfResponder), messageSentAsync)
 	if errSending != nil {
 		t.Fatal(errSending)
 	}

exchange/bitswap/testutils.go

@@ -16,6 +16,7 @@ func NewSessionGenerator(
 	return SessionGenerator{
 		net: net,
 		rs:  rs,
+		ps:  peer.NewPeerstore(),
 		seq: 0,
 	}
 }
@@ -24,11 +25,12 @@ type SessionGenerator struct {
 	seq int
 	net tn.Network
 	rs  mock.RoutingServer
+	ps  peer.Peerstore
 }
 
 func (g *SessionGenerator) Next() Instance {
 	g.seq++
-	return session(g.net, g.rs, []byte(string(g.seq)))
+	return session(g.net, g.rs, g.ps, []byte(string(g.seq)))
 }
 
 func (g *SessionGenerator) Instances(n int) []Instance {
@@ -51,8 +53,8 @@ type Instance struct {
 // NB: It's easy make mistakes by providing the same peer ID to two different
 // sessions. To safeguard, use the SessionGenerator to generate sessions. It's
 // just a much better idea.
-func session(net tn.Network, rs mock.RoutingServer, id peer.ID) Instance {
-	p := peer.WithID(id)
+func session(net tn.Network, rs mock.RoutingServer, ps peer.Peerstore, id peer.ID) Instance {
+	p := ps.WithID(id)
 
 	adapter := net.Adapter(p)
 	htc := rs.Client(p)

importer/importer_test.go

@@ -12,7 +12,7 @@ import (
 	"github.com/jbenet/go-ipfs/importer/chunk"
 	uio "github.com/jbenet/go-ipfs/unixfs/io"
 	u "github.com/jbenet/go-ipfs/util"
-	"github.com/jbenet/go-ipfs/util/testutil"
+	testutil "github.com/jbenet/go-ipfs/util/testutil"
 )
 
 // NOTE:

namesys/resolve_test.go

@@ -5,13 +5,13 @@ import (
 
 	ds "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-datastore"
 	ci "github.com/jbenet/go-ipfs/crypto"
-	"github.com/jbenet/go-ipfs/peer"
 	mock "github.com/jbenet/go-ipfs/routing/mock"
 	u "github.com/jbenet/go-ipfs/util"
+	testutil "github.com/jbenet/go-ipfs/util/testutil"
 )
 
 func TestRoutingResolve(t *testing.T) {
-	local := peer.WithIDString("testID")
+	local := testutil.NewPeerWithIDString("testID")
 	lds := ds.NewMapDatastore()
 	d := mock.NewMockRouter(local, lds)
 

net/conn/dial_test.go

@@ -5,6 +5,7 @@ import (
 
 	ci "github.com/jbenet/go-ipfs/crypto"
 	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"
 	ma "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr"
@@ -21,7 +22,7 @@ func setupPeer(addr string) (peer.Peer, error) {
 		return nil, err
 	}
 
-	p, err := peer.WithKeyPair(sk, pk)
+	p, err := testutil.NewPeerWithKeyPair(sk, pk)
 	if err != nil {
 		return nil, err
 	}

net/mux/mux_test.go

@@ -11,6 +11,7 @@ import (
 	msg "github.com/jbenet/go-ipfs/net/message"
 	pb "github.com/jbenet/go-ipfs/net/mux/internal/pb"
 	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"
 )
@@ -30,7 +31,7 @@ func newPeer(t *testing.T, id string) peer.Peer {
 		return nil
 	}
 
-	return peer.WithID(peer.ID(mh))
+	return testutil.NewPeerWithID(peer.ID(mh))
 }
 
 func testMsg(t *testing.T, m msg.NetMessage, data []byte) {

net/service/service_test.go

@@ -7,6 +7,7 @@ import (
 
 	msg "github.com/jbenet/go-ipfs/net/message"
 	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"
 	mh "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multihash"
@@ -32,7 +33,7 @@ func newPeer(t *testing.T, id string) peer.Peer {
 		return nil
 	}
 
-	return peer.WithID(peer.ID(mh))
+	return testutil.NewPeerWithID(peer.ID(mh))
 }
 
 func TestServiceHandler(t *testing.T) {

net/swarm/simul_test.go

@@ -6,6 +6,7 @@ import (
 	"testing"
 
 	peer "github.com/jbenet/go-ipfs/peer"
+	"github.com/jbenet/go-ipfs/util/testutil"
 
 	context "github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/go.net/context"
 )
@@ -28,7 +29,7 @@ func TestSimultOpen(t *testing.T) {
 		var wg sync.WaitGroup
 		connect := func(s *Swarm, dst peer.Peer) {
 			// copy for other peer
-			cp := peer.WithID(dst.ID())
+			cp := testutil.NewPeerWithID(dst.ID())
 			cp.AddAddress(dst.Addresses()[0])
 
 			if _, err := s.Dial(cp); err != nil {

net/swarm/swarm_test.go

@@ -10,6 +10,7 @@ import (
 	msg "github.com/jbenet/go-ipfs/net/message"
 	peer "github.com/jbenet/go-ipfs/peer"
 	u "github.com/jbenet/go-ipfs/util"
+	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"
@@ -43,7 +44,7 @@ func setupPeer(t *testing.T, addr string) peer.Peer {
 		t.Fatal(err)
 	}
 
-	p, err := peer.WithKeyPair(sk, pk)
+	p, err := testutil.NewPeerWithKeyPair(sk, pk)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -84,7 +85,7 @@ func SubtestSwarm(t *testing.T, addrs []string, MsgNum int) {
 		connect := func(s *Swarm, dst peer.Peer) {
 			// copy for other peer
 
-			cp, err := s.peers.Get(dst.ID())
+			cp, err := s.peers.FindOrCreate(dst.ID())
 			if err != nil {
 				t.Fatal(err)
 			}