The Peer is Dead. Long live the ID

Makefile

@@ -18,8 +18,6 @@ test: test_go test_sharness
 test_expensive: test_go_expensive test_sharness_expensive
 
 test_docker:
-	cd ./src/github.com/jbenet/go-ipfs
-	docker build -t zaqwsx_ipfs-test-img .
 	cd dockertest/ && make
 
 test_go:

blockservice/blockservice.go

@@ -41,7 +41,6 @@ func New(bs blockstore.Blockstore, rem exchange.Interface) (*BlockService, error
 // TODO pass a context into this if the remote.HasBlock is going to remain here.
 func (s *BlockService) AddBlock(b *blocks.Block) (u.Key, error) {
 	k := b.Key()
-	log.Debugf("blockservice: storing [%s] in datastore", k)
 	err := s.Blockstore.Put(b)
 	if err != nil {
 		return k, err

blockservice/mock.go

@@ -11,9 +11,8 @@ import (
 
 // Mocks returns |n| connected mock Blockservices
 func Mocks(t *testing.T, n int) []*BlockService {
-	net := tn.VirtualNetwork(delay.Fixed(0))
-	rs := mockrouting.NewServer()
-	sg := bitswap.NewSessionGenerator(net, rs)
+	net := tn.VirtualNetwork(mockrouting.NewServer(), delay.Fixed(0))
+	sg := bitswap.NewSessionGenerator(net)
 
 	instances := sg.Instances(n)
 

cmd/ipfs/init.go

@@ -266,7 +266,7 @@ func identityConfig(nbits int) (config.Identity, error) {
 	}
 	ident.PrivKey = base64.StdEncoding.EncodeToString(skbytes)
 
-	id, err := peer.IDFromPubKey(pk)
+	id, err := peer.IDFromPublicKey(pk)
 	if err != nil {
 		return ident, err
 	}

cmd/seccat/seccat.go

@@ -109,24 +109,28 @@ func main() {
 	}
 }
 
-func setupPeer(a args) (peer.Peer, peer.Peerstore, error) {
+func setupPeer(a args) (peer.ID, peer.Peerstore, error) {
 	if a.keybits < 1024 {
-		return nil, nil, errors.New("Bitsize less than 1024 is considered unsafe.")
+		return "", nil, errors.New("Bitsize less than 1024 is considered unsafe.")
 	}
 
 	out("generating key pair...")
 	sk, pk, err := ci.GenerateKeyPair(ci.RSA, a.keybits)
 	if err != nil {
-		return nil, nil, err
+		return "", nil, err
 	}
 
-	ps := peer.NewPeerstore()
-	peer, err := ps.WithKeyPair(sk, pk)
+	p, err := peer.IDFromPublicKey(pk)
 	if err != nil {
-		return nil, nil, err
+		return "", nil, err
 	}
-	out("local peer id: %s", peer.ID())
-	return peer, ps, nil
+
+	ps := peer.NewPeerstore()
+	ps.AddPrivKey(p, sk)
+	ps.AddPubKey(p, pk)
+
+	out("local peer id: %s", p)
+	return p, ps, nil
 }
 
 func connect(args args) error {
@@ -149,12 +153,13 @@ func connect(args args) error {
 	rwc := &logRW{n: "conn", rw: conn}
 
 	// OK, let's setup the channel.
-	sg := secio.SessionGenerator{Local: p, Peerstore: ps}
+	sk := ps.PrivKey(p)
+	sg := secio.SessionGenerator{LocalID: p, PrivateKey: sk}
 	sess, err := sg.NewSession(nil, rwc)
 	if err != nil {
 		return err
 	}
-	out("remote peer id: %s", sess.RemotePeer().ID())
+	out("remote peer id: %s", sess.RemotePeer())
 	netcat(sess.ReadWriter().(io.ReadWriteCloser))
 	return nil
 }

config/config.go

@@ -2,12 +2,11 @@
 package config
 
 import (
-	"crypto"
-	"crypto/x509"
 	"encoding/base64"
 	"os"
 	"path/filepath"
 
+	ic "github.com/jbenet/go-ipfs/crypto"
 	u "github.com/jbenet/go-ipfs/util"
 	"github.com/jbenet/go-ipfs/util/debugerror"
 )
@@ -132,15 +131,15 @@ func Filename(configroot string) (string, error) {
 }
 
 // DecodePrivateKey is a helper to decode the users PrivateKey
-func (i *Identity) DecodePrivateKey(passphrase string) (crypto.PrivateKey, error) {
+func (i *Identity) DecodePrivateKey(passphrase string) (ic.PrivKey, error) {
 	pkb, err := base64.StdEncoding.DecodeString(i.PrivKey)
 	if err != nil {
 		return nil, err
 	}
 
 	// currently storing key unencrypted. in the future we need to encrypt it.
 	// TODO(security)
-	return x509.ParsePKCS1PrivateKey(pkb)
+	return ic.UnmarshalPrivateKey(pkb)
 }
 
 // Load reads given file and returns the read config, or error.