break merkledag utils into its own package

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

node.go

@@ -153,6 +153,15 @@ func (n *Node) GetNodeLink(name string) (*Link, error) {
 	return nil, ErrNotFound
 }
 
+func (n *Node) GetLinkedNode(ctx context.Context, ds DAGService, name string) (*Node, error) {
+	lnk, err := n.GetNodeLink(name)
+	if err != nil {
+		return nil, err
+	}
+
+	return lnk.GetNode(ctx, ds)
+}
+
 // Copy returns a copy of the node.
 // NOTE: does not make copies of Node objects in the links.
 func (n *Node) Copy() *Node {

utils/utils.go

+package dagutils
+
+import (
+	"errors"
+	"time"
+
+	context "github.com/ipfs/go-ipfs/Godeps/_workspace/src/golang.org/x/net/context"
+
+	key "github.com/ipfs/go-ipfs/blocks/key"
+	dag "github.com/ipfs/go-ipfs/merkledag"
+	ft "github.com/ipfs/go-ipfs/unixfs"
+)
+
+func AddLink(ctx context.Context, ds dag.DAGService, root *dag.Node, childname string, childk key.Key) (*dag.Node, error) {
+	if childname == "" {
+		return nil, errors.New("cannot create link with no name!")
+	}
+
+	ctx, cancel := context.WithTimeout(ctx, time.Second*30)
+	defer cancel()
+	childnd, err := ds.Get(ctx, childk)
+	if err != nil {
+		return nil, err
+	}
+
+	// ensure no link with that name already exists
+	_ = root.RemoveNodeLink(childname) // ignore error, only option is ErrNotFound
+
+	err = root.AddNodeLinkClean(childname, childnd)
+	if err != nil {
+		return nil, err
+	}
+
+	_, err = ds.Add(root)
+	if err != nil {
+		return nil, err
+	}
+	return root, nil
+}
+
+func InsertNodeAtPath(ctx context.Context, ds dag.DAGService, root *dag.Node, path []string, toinsert key.Key, create bool) (*dag.Node, error) {
+	if len(path) == 1 {
+		return AddLink(ctx, ds, root, path[0], toinsert)
+	}
+
+	nd, err := root.GetLinkedNode(ctx, ds, path[0])
+	if err != nil {
+		// if 'create' is true, we create directories on the way down as needed
+		if err == dag.ErrNotFound && create {
+			nd = &dag.Node{Data: ft.FolderPBData()}
+		} else {
+			return nil, err
+		}
+	}
+
+	ndprime, err := InsertNodeAtPath(ctx, ds, nd, path[1:], toinsert, create)
+	if err != nil {
+		return nil, err
+	}
+
+	_ = root.RemoveNodeLink(path[0])
+	err = root.AddNodeLinkClean(path[0], ndprime)
+	if err != nil {
+		return nil, err
+	}
+
+	_, err = ds.Add(root)
+	if err != nil {
+		return nil, err
+	}
+
+	return root, nil
+}
+
+func RmLink(ctx context.Context, ds dag.DAGService, root *dag.Node, path []string) (*dag.Node, error) {
+	if len(path) == 1 {
+		// base case, remove node in question
+		err := root.RemoveNodeLink(path[0])
+		if err != nil {
+			return nil, err
+		}
+
+		_, err = ds.Add(root)
+		if err != nil {
+			return nil, err
+		}
+
+		return root, nil
+	}
+
+	nd, err := root.GetLinkedNode(ctx, ds, path[0])
+	if err != nil {
+		return nil, err
+	}
+
+	nnode, err := RmLink(ctx, ds, nd, path[1:])
+	if err != nil {
+		return nil, err
+	}
+
+	_ = root.RemoveNodeLink(path[0])
+	err = root.AddNodeLinkClean(path[0], nnode)
+	if err != nil {
+		return nil, err
+	}
+
+	_, err = ds.Add(root)
+	if err != nil {
+		return nil, err
+	}
+
+	return root, nil
+}

utils/utils_test.go

+package dagutils
+
+import (
+	"testing"
+
+	key "github.com/ipfs/go-ipfs/blocks/key"
+	dag "github.com/ipfs/go-ipfs/merkledag"
+	mdtest "github.com/ipfs/go-ipfs/merkledag/test"
+
+	context "github.com/ipfs/go-ipfs/Godeps/_workspace/src/golang.org/x/net/context"
+)
+
+func TestAddLink(t *testing.T) {
+	ds := mdtest.Mock(t)
+	fishnode := &dag.Node{
+		Data: []byte("fishcakes!"),
+	}
+
+	fk, err := ds.Add(fishnode)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	nd := new(dag.Node)
+	nnode, err := AddLink(context.Background(), ds, nd, "fish", fk)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	fnprime, err := nnode.GetLinkedNode(context.Background(), ds, "fish")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	fnpkey, err := fnprime.Key()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if fnpkey != fk {
+		t.Fatal("wrong child node found!")
+	}
+}
+
+func assertNodeAtPath(t *testing.T, ds dag.DAGService, root *dag.Node, path []string, exp key.Key) {
+	cur := root
+	for _, e := range path {
+		nxt, err := cur.GetLinkedNode(context.Background(), ds, e)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		cur = nxt
+	}
+
+	curk, err := cur.Key()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if curk != exp {
+		t.Fatal("node not as expected at end of path")
+	}
+}
+
+func TestInsertNode(t *testing.T) {
+	ds := mdtest.Mock(t)
+	root := new(dag.Node)
+
+	childa := &dag.Node{
+		Data: []byte("This is child A"),
+	}
+	ak, err := ds.Add(childa)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	path := []string{"a", "b", "c", "d"}
+	root_a, err := InsertNodeAtPath(context.Background(), ds, root, path, ak, true)
+	if err != nil {
+		t.Fatal(err)
+	}
+	assertNodeAtPath(t, ds, root_a, path, ak)
+
+	childb := &dag.Node{Data: []byte("this is the second child")}
+	bk, err := ds.Add(childb)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// this one should fail, we are specifying a non-existant path
+	// with create == false
+	path2 := []string{"a", "b", "e", "f"}
+	_, err = InsertNodeAtPath(context.Background(), ds, root_a, path2, bk, false)
+	if err == nil {
+		t.Fatal("that shouldnt have worked")
+	}
+	if err != dag.ErrNotFound {
+		t.Fatal("expected this to fail with 'not found'")
+	}
+
+	// inserting a path of length one should work with create == false
+	path3 := []string{"x"}
+	root_b, err := InsertNodeAtPath(context.Background(), ds, root_a, path3, bk, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	assertNodeAtPath(t, ds, root_b, path3, bk)
+
+	// now try overwriting a path
+	root_c, err := InsertNodeAtPath(context.Background(), ds, root_b, path, bk, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	assertNodeAtPath(t, ds, root_c, path, bk)
+}