Wire a context down to (n *helpers.UnixfsNode) GetChild

License: MIT
Signed-off-by: rht <rhtbot@gmail.com>

importer/helpers/helpers.go

@@ -77,8 +77,8 @@ func (n *UnixfsNode) NumChildren() int {
 	return n.ufmt.NumChildren()
 }
 
-func (n *UnixfsNode) GetChild(i int, ds dag.DAGService) (*UnixfsNode, error) {
-	ctx, cancel := context.WithTimeout(context.TODO(), time.Minute)
+func (n *UnixfsNode) GetChild(ctx context.Context, i int, ds dag.DAGService) (*UnixfsNode, error) {
+	ctx, cancel := context.WithTimeout(ctx, time.Minute)
 	defer cancel()
 
 	nd, err := n.node.Links[i].GetNode(ctx, ds)

importer/trickle/trickle_test.go

@@ -443,7 +443,8 @@ func TestAppend(t *testing.T) {
 	r := bytes.NewReader(should[nbytes/2:])
 	blks, errs := chunk.Chan(chunk.NewSizeSplitter(r, 500))
 
-	nnode, err := TrickleAppend(nd, dbp.New(blks, errs))
+	ctx := context.TODO()
+	nnode, err := TrickleAppend(ctx, nd, dbp.New(blks, errs))
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -453,7 +454,7 @@ func TestAppend(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	fread, err := uio.NewDagReader(context.TODO(), nnode, ds)
+	fread, err := uio.NewDagReader(ctx, nnode, ds)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -491,10 +492,11 @@ func TestMultipleAppends(t *testing.T) {
 
 	spl := chunk.SizeSplitterGen(500)
 
+	ctx := context.TODO()
 	for i := 0; i < len(should); i++ {
 		blks, errs := chunk.Chan(spl(bytes.NewReader(should[i : i+1])))
 
-		nnode, err := TrickleAppend(nd, dbp.New(blks, errs))
+		nnode, err := TrickleAppend(ctx, nd, dbp.New(blks, errs))
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -504,7 +506,7 @@ func TestMultipleAppends(t *testing.T) {
 			t.Fatal(err)
 		}
 
-		fread, err := uio.NewDagReader(context.TODO(), nnode, ds)
+		fread, err := uio.NewDagReader(ctx, nnode, ds)
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -538,19 +540,20 @@ func TestAppendSingleBytesToEmpty(t *testing.T) {
 
 	blks, errs := chunk.Chan(spl(bytes.NewReader(data[:1])))
 
-	nnode, err := TrickleAppend(nd, dbp.New(blks, errs))
+	ctx := context.TODO()
+	nnode, err := TrickleAppend(ctx, nd, dbp.New(blks, errs))
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	blks, errs = chunk.Chan(spl(bytes.NewReader(data[1:])))
 
-	nnode, err = TrickleAppend(nnode, dbp.New(blks, errs))
+	nnode, err = TrickleAppend(ctx, nnode, dbp.New(blks, errs))
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	fread, err := uio.NewDagReader(context.TODO(), nnode, ds)
+	fread, err := uio.NewDagReader(ctx, nnode, ds)
 	if err != nil {
 		t.Fatal(err)
 	}

importer/trickle/trickledag.go

@@ -18,19 +18,16 @@ const layerRepeat = 4
 
 func TrickleLayout(db *h.DagBuilderHelper) (*dag.Node, error) {
 	root := h.NewUnixfsNode()
-	err := db.FillNodeLayer(root)
-	if err != nil {
+	if err := db.FillNodeLayer(root); err != nil {
 		return nil, err
 	}
 	for level := 1; !db.Done(); level++ {
 		for i := 0; i < layerRepeat && !db.Done(); i++ {
 			next := h.NewUnixfsNode()
-			err := fillTrickleRec(db, next, level)
-			if err != nil {
+			if err := fillTrickleRec(db, next, level); err != nil {
 				return nil, err
 			}
-			err = root.AddChild(next, db)
-			if err != nil {
+			if err := root.AddChild(next, db); err != nil {
 				return nil, err
 			}
 		}
@@ -41,8 +38,7 @@ func TrickleLayout(db *h.DagBuilderHelper) (*dag.Node, error) {
 		return nil, err
 	}
 
-	err = db.Close()
-	if err != nil {
+	if err := db.Close(); err != nil {
 		return nil, err
 	}
 
@@ -51,21 +47,18 @@ func TrickleLayout(db *h.DagBuilderHelper) (*dag.Node, error) {
 
 func fillTrickleRec(db *h.DagBuilderHelper, node *h.UnixfsNode, depth int) error {
 	// Always do this, even in the base case
-	err := db.FillNodeLayer(node)
-	if err != nil {
+	if err := db.FillNodeLayer(node); err != nil {
 		return err
 	}
 
 	for i := 1; i < depth && !db.Done(); i++ {
 		for j := 0; j < layerRepeat && !db.Done(); j++ {
 			next := h.NewUnixfsNode()
-			err := fillTrickleRec(db, next, i)
-			if err != nil {
+			if err := fillTrickleRec(db, next, i); err != nil {
 				return err
 			}
 
-			err = node.AddChild(next, db)
-			if err != nil {
+			if err := node.AddChild(next, db); err != nil {
 				return err
 			}
 		}
@@ -74,11 +67,10 @@ func fillTrickleRec(db *h.DagBuilderHelper, node *h.UnixfsNode, depth int) error
 }
 
 // TrickleAppend appends the data in `db` to the dag, using the Trickledag format
-func TrickleAppend(base *dag.Node, db *h.DagBuilderHelper) (out *dag.Node, err_out error) {
+func TrickleAppend(ctx context.Context, base *dag.Node, db *h.DagBuilderHelper) (out *dag.Node, err_out error) {
 	defer func() {
 		if err_out == nil {
-			err := db.Close()
-			if err != nil {
+			if err := db.Close(); err != nil {
 				err_out = err
 			}
 		}
@@ -94,8 +86,7 @@ func TrickleAppend(base *dag.Node, db *h.DagBuilderHelper) (out *dag.Node, err_o
 	n, layerProgress := trickleDepthInfo(ufsn, db.Maxlinks())
 	if n == 0 {
 		// If direct blocks not filled...
-		err := db.FillNodeLayer(ufsn)
-		if err != nil {
+		if err := db.FillNodeLayer(ufsn); err != nil {
 			return nil, err
 		}
 
@@ -108,7 +99,7 @@ func TrickleAppend(base *dag.Node, db *h.DagBuilderHelper) (out *dag.Node, err_o
 	}
 
 	// Last child in this node may not be a full tree, lets file it up
-	if err := appendFillLastChild(ufsn, n-1, layerProgress, db); err != nil {
+	if err := appendFillLastChild(ctx, ufsn, n-1, layerProgress, db); err != nil {
 		return nil, err
 	}
 
@@ -138,19 +129,19 @@ func TrickleAppend(base *dag.Node, db *h.DagBuilderHelper) (out *dag.Node, err_o
 
 // appendFillLastChild will take in an incomplete trickledag node (uncomplete meaning, not full) and
 // fill it out to the specified depth with blocks from the given DagBuilderHelper
-func appendFillLastChild(ufsn *h.UnixfsNode, depth int, layerFill int, db *h.DagBuilderHelper) error {
+func appendFillLastChild(ctx context.Context, ufsn *h.UnixfsNode, depth int, layerFill int, db *h.DagBuilderHelper) error {
 	if ufsn.NumChildren() <= db.Maxlinks() {
 		return nil
 	}
 	// Recursive step, grab last child
 	last := ufsn.NumChildren() - 1
-	lastChild, err := ufsn.GetChild(last, db.GetDagServ())
+	lastChild, err := ufsn.GetChild(ctx, last, db.GetDagServ())
 	if err != nil {
 		return err
 	}
 
 	// Fill out last child (may not be full tree)
-	nchild, err := trickleAppendRec(lastChild, db, depth-1)
+	nchild, err := trickleAppendRec(ctx, lastChild, db, depth-1)
 	if err != nil {
 		return err
 	}
@@ -182,7 +173,7 @@ func appendFillLastChild(ufsn *h.UnixfsNode, depth int, layerFill int, db *h.Dag
 }
 
 // recursive call for TrickleAppend
-func trickleAppendRec(ufsn *h.UnixfsNode, db *h.DagBuilderHelper, depth int) (*h.UnixfsNode, error) {
+func trickleAppendRec(ctx context.Context, ufsn *h.UnixfsNode, db *h.DagBuilderHelper, depth int) (*h.UnixfsNode, error) {
 	if depth == 0 || db.Done() {
 		return ufsn, nil
 	}
@@ -191,8 +182,7 @@ func trickleAppendRec(ufsn *h.UnixfsNode, db *h.DagBuilderHelper, depth int) (*h
 	n, layerProgress := trickleDepthInfo(ufsn, db.Maxlinks())
 	if n == 0 {
 		// If direct blocks not filled...
-		err := db.FillNodeLayer(ufsn)
-		if err != nil {
+		if err := db.FillNodeLayer(ufsn); err != nil {
 			return nil, err
 		}
 		n++
@@ -203,8 +193,7 @@ func trickleAppendRec(ufsn *h.UnixfsNode, db *h.DagBuilderHelper, depth int) (*h
 		return ufsn, nil
 	}
 
-	err := appendFillLastChild(ufsn, n, layerProgress, db)
-	if err != nil {
+	if err := appendFillLastChild(ctx, ufsn, n, layerProgress, db); err != nil {
 		return nil, err
 	}
 
@@ -217,13 +206,11 @@ func trickleAppendRec(ufsn *h.UnixfsNode, db *h.DagBuilderHelper, depth int) (*h
 	for i := n; i < depth && !db.Done(); i++ {
 		for j := 0; j < layerRepeat && !db.Done(); j++ {
 			next := h.NewUnixfsNode()
-			err := fillTrickleRec(db, next, i)
-			if err != nil {
+			if err := fillTrickleRec(db, next, i); err != nil {
 				return nil, err
 			}
 
-			err = ufsn.AddChild(next, db)
-			if err != nil {
+			if err := ufsn.AddChild(next, db); err != nil {
 				return nil, err
 			}
 		}

unixfs/mod/dagmodifier.go

@@ -312,7 +312,7 @@ func (dm *DagModifier) appendData(node *mdag.Node, blks <-chan []byte, errs <-ch
 		NodeCB:   imp.BasicPinnerCB(dm.mp),
 	}
 
-	return trickle.TrickleAppend(node, dbp.New(blks, errs))
+	return trickle.TrickleAppend(dm.ctx, node, dbp.New(blks, errs))
 }
 
 // Read data from this dag starting at the current offset