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

rht · rht · commit 68c51b8b36d8 · 2015-08-20T07:59:52.000+07:00
License: MIT
Signed-off-by: rht &lt;rhtbot@gmail.com&gt;
diff --git a/importer/helpers/helpers.go b/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)
diff --git a/importer/trickle/trickledag.go b/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
 			}
 		}
diff --git a/unixfs/mod/dagmodifier.go b/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

Original file line number	Diff line number	Diff line change
`@@ -77,8 +77,8 @@ func (n *UnixfsNode) NumChildren() int {`
`77`	`77`	`return n.ufmt.NumChildren()`
`78`	`78`	`}`
`79`	`79`
`80`		`-func (n UnixfsNode) GetChild(i int, ds dag.DAGService) (UnixfsNode, error) {`
`81`		`- ctx, cancel := context.WithTimeout(context.TODO(), time.Minute)`
	`80`	`+func (n UnixfsNode) GetChild(ctx context.Context, i int, ds dag.DAGService) (UnixfsNode, error) {`
	`81`	`+ ctx, cancel := context.WithTimeout(ctx, time.Minute)`
`82`	`82`	`defer cancel()`
`83`	`83`
`84`	`84`	`nd, err := n.node.Links[i].GetNode(ctx, ds)`
Original file line number	Diff line number	Diff line change
`@@ -18,19 +18,16 @@ const layerRepeat = 4`
`18`	`18`
`19`	`19`	`func TrickleLayout(db h.DagBuilderHelper) (dag.Node, error) {`
`20`	`20`	`root := h.NewUnixfsNode()`
`21`		`- err := db.FillNodeLayer(root)`
`22`		`- if err != nil {`
	`21`	`+ if err := db.FillNodeLayer(root); err != nil {`
`23`	`22`	`return nil, err`
`24`	`23`	`}`
`25`	`24`	`for level := 1; !db.Done(); level++ {`
`26`	`25`	`for i := 0; i < layerRepeat && !db.Done(); i++ {`
`27`	`26`	`next := h.NewUnixfsNode()`
`28`		`- err := fillTrickleRec(db, next, level)`
`29`		`- if err != nil {`
	`27`	`+ if err := fillTrickleRec(db, next, level); err != nil {`
`30`	`28`	`return nil, err`
`31`	`29`	`}`
`32`		`- err = root.AddChild(next, db)`
`33`		`- if err != nil {`
	`30`	`+ if err := root.AddChild(next, db); err != nil {`
`34`	`31`	`return nil, err`
`35`	`32`	`}`
`36`	`33`	`}`
`@@ -41,8 +38,7 @@ func TrickleLayout(db h.DagBuilderHelper) (dag.Node, error) {`
`41`	`38`	`return nil, err`
`42`	`39`	`}`
`43`	`40`
`44`		`- err = db.Close()`
`45`		`- if err != nil {`
	`41`	`+ if err := db.Close(); err != nil {`
`46`	`42`	`return nil, err`
`47`	`43`	`}`
`48`	`44`
`@@ -51,21 +47,18 @@ func TrickleLayout(db h.DagBuilderHelper) (dag.Node, error) {`
`51`	`47`
`52`	`48`	`func fillTrickleRec(db h.DagBuilderHelper, node h.UnixfsNode, depth int) error {`
`53`	`49`	`// Always do this, even in the base case`
`54`		`- err := db.FillNodeLayer(node)`
`55`		`- if err != nil {`
	`50`	`+ if err := db.FillNodeLayer(node); err != nil {`
`56`	`51`	`return err`
`57`	`52`	`}`
`58`	`53`
`59`	`54`	`for i := 1; i < depth && !db.Done(); i++ {`
`60`	`55`	`for j := 0; j < layerRepeat && !db.Done(); j++ {`
`61`	`56`	`next := h.NewUnixfsNode()`
`62`		`- err := fillTrickleRec(db, next, i)`
`63`		`- if err != nil {`
	`57`	`+ if err := fillTrickleRec(db, next, i); err != nil {`
`64`	`58`	`return err`
`65`	`59`	`}`
`66`	`60`
`67`		`- err = node.AddChild(next, db)`
`68`		`- if err != nil {`
	`61`	`+ if err := node.AddChild(next, db); err != nil {`
`69`	`62`	`return err`
`70`	`63`	`}`
`71`	`64`	`}`
`@@ -74,11 +67,10 @@ func fillTrickleRec(db h.DagBuilderHelper, node h.UnixfsNode, depth int) error`
`74`	`67`	`}`
`75`	`68`
`76`	`69`	// TrickleAppend appends the data in `db` to the dag, using the Trickledag format
`77`		`-func TrickleAppend(base dag.Node, db h.DagBuilderHelper) (out *dag.Node, err_out error) {`
	`70`	`+func TrickleAppend(ctx context.Context, base dag.Node, db h.DagBuilderHelper) (out *dag.Node, err_out error) {`
`78`	`71`	`defer func() {`
`79`	`72`	`if err_out == nil {`
`80`		`- err := db.Close()`
`81`		`- if err != nil {`
	`73`	`+ if err := db.Close(); err != nil {`
`82`	`74`	`err_out = err`
`83`	`75`	`}`
`84`	`76`	`}`
`@@ -94,8 +86,7 @@ func TrickleAppend(base dag.Node, db h.DagBuilderHelper) (out *dag.Node, err_o`
`94`	`86`	`n, layerProgress := trickleDepthInfo(ufsn, db.Maxlinks())`
`95`	`87`	`if n == 0 {`
`96`	`88`	`// If direct blocks not filled...`
`97`		`- err := db.FillNodeLayer(ufsn)`
`98`		`- if err != nil {`
	`89`	`+ if err := db.FillNodeLayer(ufsn); err != nil {`
`99`	`90`	`return nil, err`
`100`	`91`	`}`
`101`	`92`
`@@ -108,7 +99,7 @@ func TrickleAppend(base dag.Node, db h.DagBuilderHelper) (out *dag.Node, err_o`
`108`	`99`	`}`
`109`	`100`
`110`	`101`	`// Last child in this node may not be a full tree, lets file it up`
`111`		`- if err := appendFillLastChild(ufsn, n-1, layerProgress, db); err != nil {`
	`102`	`+ if err := appendFillLastChild(ctx, ufsn, n-1, layerProgress, db); err != nil {`
`112`	`103`	`return nil, err`
`113`	`104`	`}`
`114`	`105`
`@@ -138,19 +129,19 @@ func TrickleAppend(base dag.Node, db h.DagBuilderHelper) (out *dag.Node, err_o`
`138`	`129`
`139`	`130`	`// appendFillLastChild will take in an incomplete trickledag node (uncomplete meaning, not full) and`
`140`	`131`	`// fill it out to the specified depth with blocks from the given DagBuilderHelper`
`141`		`-func appendFillLastChild(ufsn h.UnixfsNode, depth int, layerFill int, db h.DagBuilderHelper) error {`
	`132`	`+func appendFillLastChild(ctx context.Context, ufsn h.UnixfsNode, depth int, layerFill int, db h.DagBuilderHelper) error {`
`142`	`133`	`if ufsn.NumChildren() <= db.Maxlinks() {`
`143`	`134`	`return nil`
`144`	`135`	`}`
`145`	`136`	`// Recursive step, grab last child`
`146`	`137`	`last := ufsn.NumChildren() - 1`
`147`		`- lastChild, err := ufsn.GetChild(last, db.GetDagServ())`
	`138`	`+ lastChild, err := ufsn.GetChild(ctx, last, db.GetDagServ())`
`148`	`139`	`if err != nil {`
`149`	`140`	`return err`
`150`	`141`	`}`
`151`	`142`
`152`	`143`	`// Fill out last child (may not be full tree)`
`153`		`- nchild, err := trickleAppendRec(lastChild, db, depth-1)`
	`144`	`+ nchild, err := trickleAppendRec(ctx, lastChild, db, depth-1)`
`154`	`145`	`if err != nil {`
`155`	`146`	`return err`
`156`	`147`	`}`
`@@ -182,7 +173,7 @@ func appendFillLastChild(ufsn h.UnixfsNode, depth int, layerFill int, db h.Dag`
`182`	`173`	`}`
`183`	`174`
`184`	`175`	`// recursive call for TrickleAppend`
`185`		`-func trickleAppendRec(ufsn h.UnixfsNode, db h.DagBuilderHelper, depth int) (*h.UnixfsNode, error) {`
	`176`	`+func trickleAppendRec(ctx context.Context, ufsn h.UnixfsNode, db h.DagBuilderHelper, depth int) (*h.UnixfsNode, error) {`
`186`	`177`	`if depth == 0 \|\| db.Done() {`
`187`	`178`	`return ufsn, nil`
`188`	`179`	`}`
`@@ -191,8 +182,7 @@ func trickleAppendRec(ufsn h.UnixfsNode, db h.DagBuilderHelper, depth int) (*h`
`191`	`182`	`n, layerProgress := trickleDepthInfo(ufsn, db.Maxlinks())`
`192`	`183`	`if n == 0 {`
`193`	`184`	`// If direct blocks not filled...`
`194`		`- err := db.FillNodeLayer(ufsn)`
`195`		`- if err != nil {`
	`185`	`+ if err := db.FillNodeLayer(ufsn); err != nil {`
`196`	`186`	`return nil, err`
`197`	`187`	`}`
`198`	`188`	`n++`
`@@ -203,8 +193,7 @@ func trickleAppendRec(ufsn h.UnixfsNode, db h.DagBuilderHelper, depth int) (*h`
`203`	`193`	`return ufsn, nil`
`204`	`194`	`}`
`205`	`195`
`206`		`- err := appendFillLastChild(ufsn, n, layerProgress, db)`
`207`		`- if err != nil {`
	`196`	`+ if err := appendFillLastChild(ctx, ufsn, n, layerProgress, db); err != nil {`
`208`	`197`	`return nil, err`
`209`	`198`	`}`
`210`	`199`
`@@ -217,13 +206,11 @@ func trickleAppendRec(ufsn h.UnixfsNode, db h.DagBuilderHelper, depth int) (*h`
`217`	`206`	`for i := n; i < depth && !db.Done(); i++ {`
`218`	`207`	`for j := 0; j < layerRepeat && !db.Done(); j++ {`
`219`	`208`	`next := h.NewUnixfsNode()`
`220`		`- err := fillTrickleRec(db, next, i)`
`221`		`- if err != nil {`
	`209`	`+ if err := fillTrickleRec(db, next, i); err != nil {`
`222`	`210`	`return nil, err`
`223`	`211`	`}`
`224`	`212`
`225`		`- err = ufsn.AddChild(next, db)`
`226`		`- if err != nil {`
	`213`	`+ if err := ufsn.AddChild(next, db); err != nil {`
`227`	`214`	`return nil, err`
`228`	`215`	`}`
`229`	`216`	`}`
Original file line number	Diff line number	Diff line change
`@@ -312,7 +312,7 @@ func (dm DagModifier) appendData(node mdag.Node, blks <-chan []byte, errs <-ch`
`312`	`312`	`NodeCB: imp.BasicPinnerCB(dm.mp),`
`313`	`313`	`}`
`314`	`314`
`315`		`- return trickle.TrickleAppend(node, dbp.New(blks, errs))`
	`315`	`+ return trickle.TrickleAppend(dm.ctx, node, dbp.New(blks, errs))`
`316`	`316`	`}`
`317`	`317`
`318`	`318`	`// Read data from this dag starting at the current offset`