fix coreapi unixfs resolving

License: MIT
Signed-off-by: Jeromy <jeromyj@gmail.com>

core/coreapi/coreapi.go

@@ -6,6 +6,7 @@ import (
 	core "github.com/ipfs/go-ipfs/core"
 	coreiface "github.com/ipfs/go-ipfs/core/coreapi/interface"
 	ipfspath "github.com/ipfs/go-ipfs/path"
+	uio "github.com/ipfs/go-ipfs/unixfs/io"
 
 	cid "gx/ipfs/QmYhQaCYEcaPPjxJX7YcPcVKkQfRy6sJ7B3XmGFk82XYdQ/go-cid"
 )
@@ -42,8 +43,13 @@ func (api *CoreAPI) ResolvePath(ctx context.Context, p coreiface.Path) (coreifac
 		return p, nil
 	}
 
+	r := &ipfspath.Resolver{
+		DAG:         api.node.DAG,
+		ResolveOnce: uio.ResolveUnixfsOnce,
+	}
+
 	p2 := ipfspath.FromString(p.String())
-	node, err := core.Resolve(ctx, api.node.Namesys, api.node.Resolver, p2)
+	node, err := core.Resolve(ctx, api.node.Namesys, r, p2)
 	if err == core.ErrNoNamesys {
 		return nil, coreiface.ErrOffline
 	} else if err != nil {

core/coreapi/unixfs.go

@@ -9,6 +9,7 @@ import (
 	uio "github.com/ipfs/go-ipfs/unixfs/io"
 
 	cid "gx/ipfs/QmYhQaCYEcaPPjxJX7YcPcVKkQfRy6sJ7B3XmGFk82XYdQ/go-cid"
+	node "gx/ipfs/Qmb3Hm9QDFmfYuET4pu7Kyg8JV78jFa1nvZx5vnCZsK4ck/go-ipld-format"
 )
 
 type UnixfsAPI CoreAPI
@@ -46,9 +47,23 @@ func (api *UnixfsAPI) Ls(ctx context.Context, p coreiface.Path) ([]*coreiface.Li
 		return nil, err
 	}
 
-	l := dagnode.Links()
-	links := make([]*coreiface.Link, len(l))
-	for i, l := range l {
+	var ndlinks []*node.Link
+	dir, err := uio.NewDirectoryFromNode(api.node.DAG, dagnode)
+	switch err {
+	case nil:
+		l, err := dir.Links(ctx)
+		if err != nil {
+			return nil, err
+		}
+		ndlinks = l
+	case uio.ErrNotADir:
+		ndlinks = dagnode.Links()
+	default:
+		return nil, err
+	}
+
+	links := make([]*coreiface.Link, len(ndlinks))
+	for i, l := range ndlinks {
 		links[i] = &coreiface.Link{l.Name, l.Size, l.Cid}
 	}
 	return links, nil

core/coreapi/unixfs_test.go

@@ -16,6 +16,7 @@ import (
 	config "github.com/ipfs/go-ipfs/repo/config"
 	testutil "github.com/ipfs/go-ipfs/thirdparty/testutil"
 	unixfs "github.com/ipfs/go-ipfs/unixfs"
+	cbor "gx/ipfs/QmNrbCt8j9DT5W9Pmjy2SdudT9k8GpaDr4sRuFix3BXhgR/go-ipld-cbor"
 )
 
 // `echo -n 'hello, world!' | ipfs add`
@@ -276,7 +277,12 @@ func TestLsNonUnixfs(t *testing.T) {
 		t.Error(err)
 	}
 
-	c, err := node.DAG.Add(new(mdag.ProtoNode))
+	nd, err := cbor.WrapObject(map[string]interface{}{"foo": "bar"})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	c, err := node.DAG.Add(nd)
 	if err != nil {
 		t.Error(err)
 	}

path/resolver.go

@@ -37,7 +37,7 @@ func (e ErrNoLink) Error() string {
 type Resolver struct {
 	DAG dag.DAGService
 
-	ResolveOnce func(ctx context.Context, ds dag.DAGService, nd node.Node, name string) (*node.Link, error)
+	ResolveOnce func(ctx context.Context, ds dag.DAGService, nd node.Node, names []string) (*node.Link, []string, error)
 }
 
 func NewBasicResolver(ds dag.DAGService) *Resolver {
@@ -121,9 +121,10 @@ func (s *Resolver) ResolvePath(ctx context.Context, fpath Path) (node.Node, erro
 	return nodes[len(nodes)-1], err
 }
 
-func ResolveSingle(ctx context.Context, ds dag.DAGService, nd node.Node, name string) (*node.Link, error) {
-	lnk, _, err := nd.ResolveLink([]string{name})
-	return lnk, err
+// ResolveSingle simply resolves one hop of a path through a graph with no
+// extra context (does not opaquely resolve through sharded nodes)
+func ResolveSingle(ctx context.Context, ds dag.DAGService, nd node.Node, names []string) (*node.Link, []string, error) {
+	return nd.ResolveLink(names)
 }
 
 // ResolvePathComponents fetches the nodes for each segment of the given path.
@@ -163,7 +164,7 @@ func (s *Resolver) ResolveLinks(ctx context.Context, ndd node.Node, names []stri
 		ctx, cancel = context.WithTimeout(ctx, time.Minute)
 		defer cancel()
 
-		lnk, err := s.ResolveOnce(ctx, s.DAG, nd, names[0])
+		lnk, rest, err := s.ResolveOnce(ctx, s.DAG, nd, names)
 		if err == dag.ErrLinkNotFound {
 			return result, ErrNoLink{Name: names[0], Node: nd.Cid()}
 		} else if err != nil {
@@ -177,7 +178,7 @@ func (s *Resolver) ResolveLinks(ctx context.Context, ndd node.Node, names []stri
 
 		nd = nextnode
 		result = append(result, nextnode)
-		names = names[1:]
+		names = rest
 	}
 	return result, nil
 }

unixfs/hamt/hamt.go

@@ -191,6 +191,7 @@ type shardValue struct {
 	val *node.Link
 }
 
+// Link returns a link to this node
 func (sv *shardValue) Link() (*node.Link, error) {
 	return sv.val, nil
 }
@@ -234,7 +235,8 @@ func (ds *HamtShard) Remove(ctx context.Context, name string) error {
 	return ds.modifyValue(ctx, hv, name, nil)
 }
 
-func (ds *HamtShard) Find(ctx context.Context, name string) (node.Node, error) {
+// Find searches for a child node by 'name' within this hamt
+func (ds *HamtShard) Find(ctx context.Context, name string) (*node.Link, error) {
 	hv := &hashBits{b: hash([]byte(name))}
 
 	var out *node.Link
@@ -246,7 +248,7 @@ func (ds *HamtShard) Find(ctx context.Context, name string) (node.Node, error) {
 		return nil, err
 	}
 
-	return ds.dserv.Get(ctx, out.Cid)
+	return out, nil
 }
 
 // getChild returns the i'th child of this shard. If it is cached in the
@@ -320,6 +322,7 @@ func (ds *HamtShard) setChild(i int, c child) {
 	ds.children[i] = c
 }
 
+// Link returns a merklelink to this shard node
 func (ds *HamtShard) Link() (*node.Link, error) {
 	nd, err := ds.Node()
 	if err != nil {

unixfs/io/dirbuilder.go

@@ -48,6 +48,7 @@ func NewDirectory(dserv mdag.DAGService) *Directory {
 	return db
 }
 
+// ErrNotADir implies that the given node was not a unixfs directory
 var ErrNotADir = fmt.Errorf("merkledag node was not a directory or shard")
 
 func NewDirectoryFromNode(dserv mdag.DAGService, nd node.Node) (*Directory, error) {
@@ -167,7 +168,12 @@ func (d *Directory) Find(ctx context.Context, name string) (node.Node, error) {
 		return d.dserv.Get(ctx, lnk.Cid)
 	}
 
-	return d.shard.Find(ctx, name)
+	lnk, err := d.shard.Find(ctx, name)
+	if err != nil {
+		return nil, err
+	}
+
+	return lnk.GetNode(ctx, d.dserv)
 }
 
 func (d *Directory) RemoveChild(ctx context.Context, name string) error {

unixfs/io/resolve.go

@@ -10,37 +10,48 @@ import (
 	node "gx/ipfs/Qmb3Hm9QDFmfYuET4pu7Kyg8JV78jFa1nvZx5vnCZsK4ck/go-ipld-format"
 )
 
-func ResolveUnixfsOnce(ctx context.Context, ds dag.DAGService, nd node.Node, name string) (*node.Link, error) {
+// ResolveUnixfsOnce resolves a single hop of a path through a graph in a
+// unixfs context. This includes handling traversing sharded directories.
+func ResolveUnixfsOnce(ctx context.Context, ds dag.DAGService, nd node.Node, names []string) (*node.Link, []string, error) {
 	switch nd := nd.(type) {
 	case *dag.ProtoNode:
 		upb, err := ft.FromBytes(nd.Data())
 		if err != nil {
 			// Not a unixfs node, use standard object traversal code
-			return nd.GetNodeLink(name)
+			lnk, err := nd.GetNodeLink(names[0])
+			if err != nil {
+				return nil, nil, err
+			}
+
+			return lnk, names[1:], nil
 		}
 
 		switch upb.GetType() {
 		case ft.THAMTShard:
 			s, err := hamt.NewHamtFromDag(ds, nd)
 			if err != nil {
-				return nil, err
+				return nil, nil, err
 			}
 
-			// TODO: optimized routine on HAMT for returning a dag.Link to avoid extra disk hits
-			out, err := s.Find(ctx, name)
+			out, err := s.Find(ctx, names[0])
 			if err != nil {
-				return nil, err
+				return nil, nil, err
 			}
 
-			return node.MakeLink(out)
+			return out, names[1:], nil
 		default:
-			return nd.GetNodeLink(name)
+			lnk, err := nd.GetNodeLink(names[0])
+			if err != nil {
+				return nil, nil, err
+			}
+
+			return lnk, names[1:], nil
 		}
 	default:
-		lnk, _, err := nd.ResolveLink([]string{name})
+		lnk, rest, err := nd.ResolveLink(names)
 		if err != nil {
-			return nil, err
+			return nil, nil, err
 		}
-		return lnk, nil
+		return lnk, rest, nil
 	}
 }