opensource/kubo
1
0
Fork 0
mirror of https://github.com/ipfs/kubo.git synced 2025-09-09 19:32:24 +08:00
Code Issues Projects Releases Wiki Activity

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

Browse Source 
License: MIT
Signed-off-by: rht <rhtbot@gmail.com>
This commit is contained in:
rht
2015-08-20 07:59:52 +07:00
parent 5d8e15042f
commit 34e06f6c95
4 changed files with 32 additions and 42 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
importer/helpers/helpers.go
View File

@ -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)

17
importer/trickle/trickle_test.go
View File

@ -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)
}

51
importer/trickle/trickledag.go
View File

@ -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
}
}

2
unixfs/mod/dagmodifier.go
View File

@ -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