merkledag: Remove unused AddRecursive and RemoveRecursive

License: MIT
Signed-off-by: Mildred Ki'Lya <mildred-pub.git@mildred.fr>

core/corehttp/gateway_handler.go

@@ -453,16 +453,20 @@ func (i *gatewayHandler) deleteHandler(w http.ResponseWriter, r *http.Request) {
 	}
 
 	newnode := pathNodes[len(pathNodes)-1]
-	for i := len(pathNodes) - 2; i >= 0; i-- {
-		newnode, err = pathNodes[i].UpdateNodeLink(components[i], newnode)
+	for j := len(pathNodes) - 2; j >= 0; j-- {
+		if _, err := i.node.DAG.Add(newnode); err != nil {
+			webError(w, "Could not add node", err, http.StatusInternalServerError)
+			return
+		}
+		newnode, err = pathNodes[j].UpdateNodeLink(components[j], newnode)
 		if err != nil {
 			webError(w, "Could not update node links", err, http.StatusInternalServerError)
 			return
 		}
 	}
 
-	if err := i.node.DAG.AddRecursive(newnode); err != nil {
-		webError(w, "Could not add recursively new node", err, http.StatusInternalServerError)
+	if _, err := i.node.DAG.Add(newnode); err != nil {
+		webError(w, "Could not add root node", err, http.StatusInternalServerError)
 		return
 	}
 

core/corehttp/gateway_test.go

@@ -181,7 +181,12 @@ func TestIPNSHostnameRedirect(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	err = n.DAG.AddRecursive(dagn1)
+	_, err = n.DAG.Add(dagn2)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	_, err = n.DAG.Add(dagn1)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -266,7 +271,15 @@ func TestIPNSHostnameBacklinks(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	err = n.DAG.AddRecursive(dagn1)
+	_, err = n.DAG.Add(dagn3)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, err = n.DAG.Add(dagn2)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, err = n.DAG.Add(dagn1)
 	if err != nil {
 		t.Fatal(err)
 	}

merkledag/merkledag.go

@@ -18,10 +18,8 @@ var ErrNotFound = fmt.Errorf("merkledag: not found")
 // DAGService is an IPFS Merkle DAG service.
 type DAGService interface {
 	Add(*Node) (key.Key, error)
-	AddRecursive(*Node) error
 	Get(context.Context, key.Key) (*Node, error)
 	Remove(*Node) error
-	RemoveRecursive(*Node) error
 
 	// GetDAG returns, in order, all the single leve child
 	// nodes of the passed in node.
@@ -68,26 +66,6 @@ func (n *dagService) Batch() *Batch {
 	return &Batch{ds: n, MaxSize: 8 * 1024 * 1024}
 }
 
-// AddRecursive adds the given node and all child nodes to the BlockService
-func (n *dagService) AddRecursive(nd *Node) error {
-	_, err := n.Add(nd)
-	if err != nil {
-		log.Info("AddRecursive Error: %s\n", err)
-		return err
-	}
-
-	for _, link := range nd.Links {
-		if link.node != nil {
-			err := n.AddRecursive(link.node)
-			if err != nil {
-				return err
-			}
-		}
-	}
-
-	return nil
-}
-
 // Get retrieves a node from the dagService, fetching the block in the BlockService
 func (n *dagService) Get(ctx context.Context, k key.Key) (*Node, error) {
 	if n == nil {
@@ -107,20 +85,6 @@ func (n *dagService) Get(ctx context.Context, k key.Key) (*Node, error) {
 	return DecodeProtobuf(b.Data)
 }
 
-// Remove deletes the given node and all of its children from the BlockService
-func (n *dagService) RemoveRecursive(nd *Node) error {
-	for _, l := range nd.Links {
-		if l.node != nil {
-			n.RemoveRecursive(l.node)
-		}
-	}
-	k, err := nd.Key()
-	if err != nil {
-		return err
-	}
-	return n.Blocks.DeleteBlock(k)
-}
-
 func (n *dagService) Remove(nd *Node) error {
 	k, err := nd.Key()
 	if err != nil {

merkledag/merkledag_test.go

@@ -181,7 +181,7 @@ func runBatchFetchTest(t *testing.T, read io.Reader) {
 		t.Fatal(err)
 	}
 
-	err = dagservs[0].AddRecursive(root)
+	_, err = dagservs[0].Add(root)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -232,45 +232,6 @@ func runBatchFetchTest(t *testing.T, read io.Reader) {
 		}
 	}
 }
-func TestRecursiveAdd(t *testing.T) {
-	a := &Node{Data: []byte("A")}
-	b := &Node{Data: []byte("B")}
-	c := &Node{Data: []byte("C")}
-	d := &Node{Data: []byte("D")}
-	e := &Node{Data: []byte("E")}
-
-	err := a.AddNodeLink("blah", b)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = b.AddNodeLink("foo", c)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = b.AddNodeLink("bar", d)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = d.AddNodeLink("baz", e)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	dsp := getDagservAndPinner(t)
-	err = dsp.ds.AddRecursive(a)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	assertCanGet(t, dsp.ds, a)
-	assertCanGet(t, dsp.ds, b)
-	assertCanGet(t, dsp.ds, c)
-	assertCanGet(t, dsp.ds, d)
-	assertCanGet(t, dsp.ds, e)
-}
 
 func assertCanGet(t *testing.T, ds DAGService, n *Node) {
 	k, err := n.Key()

path/resolver_test.go

@@ -39,9 +39,11 @@ func TestRecurivePathResolution(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	err = dagService.AddRecursive(a)
-	if err != nil {
-		t.Fatal(err)
+	for _, n := range []*merkledag.Node{a, b, c} {
+		_, err = dagService.Add(n)
+		if err != nil {
+			t.Fatal(err)
+		}
 	}
 
 	aKey, err := a.Key()

pin/pin_test.go

@@ -104,7 +104,11 @@ func TestPinnerBasic(t *testing.T) {
 	d.AddNodeLink("e", e)
 
 	// Must be in dagserv for unpin to work
-	err = dserv.AddRecursive(d)
+	_, err = dserv.Add(e)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, err = dserv.Add(d)
 	if err != nil {
 		t.Fatal(err)
 	}