add routing resolver test

core/core.go

@@ -61,7 +61,7 @@ type IpfsNode struct {
 	Resolver *path.Resolver
 
 	// the name system, resolves paths to hashes
-	Namesys namesys.NSResolver
+	Namesys namesys.Resolver
 }
 
 // NewIpfsNode constructs a new IpfsNode based on the given config.
@@ -143,6 +143,7 @@ func NewIpfsNode(cfg *config.Config, online bool) (*IpfsNode, error) {
 	}
 
 	dag := &merkledag.DAGService{Blocks: bs}
+	resolve := namesys.NewMasterResolver(route, dag)
 
 	success = true
 	return &IpfsNode{
@@ -155,6 +156,7 @@ func NewIpfsNode(cfg *config.Config, online bool) (*IpfsNode, error) {
 		Exchange:  exchangeSession,
 		Identity:  local,
 		Routing:   route,
+		Namesys:   resolve,
 	}, nil
 }
 

namesys/nsresolver.go

@@ -1,5 +1,5 @@
 package namesys
 
-type NSResolver interface {
+type Resolver interface {
 	Resolve(string) (string, error)
 }

namesys/resolve_test.go

@@ -0,0 +1,66 @@
+package namesys
+
+import (
+	"testing"
+
+	ds "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/datastore.go"
+	bs "github.com/jbenet/go-ipfs/blockservice"
+	ci "github.com/jbenet/go-ipfs/crypto"
+	mdag "github.com/jbenet/go-ipfs/merkledag"
+	"github.com/jbenet/go-ipfs/peer"
+	"github.com/jbenet/go-ipfs/routing/dht"
+	"github.com/jbenet/go-ipfs/swarm"
+	u "github.com/jbenet/go-ipfs/util"
+)
+
+func TestRoutingResolve(t *testing.T) {
+	local := &peer.Peer{
+		ID: []byte("testID"),
+	}
+	net := swarm.NewSwarm(local)
+	lds := ds.NewMapDatastore()
+	d := dht.NewDHT(local, net, lds)
+
+	bserv, err := bs.NewBlockService(lds, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	dag := &mdag.DAGService{Blocks: bserv}
+
+	resolve := NewMasterResolver(d, dag)
+
+	pub := IpnsPublisher{
+		dag:     dag,
+		routing: d,
+	}
+
+	privk, pubk, err := ci.GenerateKeyPair(ci.RSA, 512)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = pub.Publish(privk, u.Key("Hello"))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	pubkb, err := pubk.Bytes()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	pkhash, err := u.Hash(pubkb)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	res, err := resolve.Resolve(u.Key(pkhash).Pretty())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if res != "Hello" {
+		t.Fatal("Got back incorrect value.")
+	}
+}

namesys/routing.go

@@ -29,6 +29,7 @@ func NewRoutingResolver(route routing.IpfsRouting, dagservice *mdag.DAGService)
 func (r *RoutingResolver) Resolve(name string) (string, error) {
 	hash, err := mh.FromB58String(name)
 	if err != nil {
+		u.DOut("RoutingResolve: bad input hash: [%s]\n", name)
 		return "", err
 	}
 	// name should be a multihash. if it isn't, error out here.
@@ -43,6 +44,7 @@ func (r *RoutingResolver) Resolve(name string) (string, error) {
 	inpsKey := u.Key(h)
 	val, err := r.routing.GetValue(inpsKey, time.Second*10)
 	if err != nil {
+		u.DOut("RoutingResolve get failed.\n")
 		return "", err
 	}
 
@@ -55,13 +57,14 @@ func (r *RoutingResolver) Resolve(name string) (string, error) {
 	// name should be a public key retrievable from ipfs
 	// /ipfs/<name>
 	key := u.Key(hash)
-	node, err := r.dag.Get(key)
+	pkval, err := r.routing.GetValue(key, time.Second*10)
 	if err != nil {
+		u.DOut("RoutingResolve PubKey Get failed.\n")
 		return "", err
 	}
 
 	// get PublicKey from node.Data
-	pk, err := ci.UnmarshalPublicKey(node.Data)
+	pk, err := ci.UnmarshalPublicKey(pkval)
 	if err != nil {
 		return "", err
 	}

routing/dht/routing.go

@@ -17,10 +17,13 @@ import (
 
 // PutValue adds value corresponding to given Key.
 // This is the top level "Store" operation of the DHT
-func (dht *IpfsDHT) PutValue(ctx context.Context, key u.Key, value []byte) error {
+func (dht *IpfsDHT) PutValue(key u.Key, value []byte) error {
-	peers := []*peer.Peer{}
+	err := dht.putLocal(key, value)
+	if err != nil {
+		return err
+	}
 
-	// get the peers we need to announce to
+	var peers []*peer.Peer
 	for _, route := range dht.routingTables {
 		npeers := route.NearestPeers(kb.ConvertKey(key), KValue)
 		peers = append(peers, npeers...)