make callback take a node instead of a key

Author: whyrusleeping

core/coreunix/add.go

@@ -17,7 +17,6 @@ import (
 	"github.com/ipfs/go-ipfs/pin"
 	"github.com/ipfs/go-ipfs/thirdparty/eventlog"
 	unixfs "github.com/ipfs/go-ipfs/unixfs"
-	u "github.com/ipfs/go-ipfs/util"
 )
 
 var log = eventlog.Logger("coreunix")
@@ -100,10 +99,7 @@ func add(n *core.IpfsNode, reader io.Reader) (*merkledag.Node, error) {
 		reader,
 		n.DAG,
 		chunk.DefaultSplitter,
-		func(k u.Key, root bool) error {
-			mp.PinWithMode(k, pin.Indirect)
-			return nil
-		},
+		importer.PinIndirectCB(mp),
 	)
 	if err != nil {
 		return nil, err

importer/helpers/dagbuilder.go

@@ -3,12 +3,11 @@ package helpers
 import (
 	dag "github.com/ipfs/go-ipfs/merkledag"
 	"github.com/ipfs/go-ipfs/pin"
-	u "github.com/ipfs/go-ipfs/util"
 )
 
-type BlockCB func(u.Key, bool) error
+type NodeCB func(node *dag.Node, root bool) error
 
-var nilFunc BlockCB = func(_ u.Key, _ bool) error { return nil }
+var nilFunc NodeCB = func(_ *dag.Node, _ bool) error { return nil }
 
 // DagBuilderHelper wraps together a bunch of objects needed to
 // efficiently create unixfs dag trees
@@ -18,7 +17,7 @@ type DagBuilderHelper struct {
 	in       <-chan []byte
 	nextData []byte // the next item to return.
 	maxlinks int
-	bcb      BlockCB
+	ncb      NodeCB
 }
 
 type DagBuilderParams struct {
@@ -29,22 +28,22 @@ type DagBuilderParams struct {
 	Dagserv dag.DAGService
 
 	// Callback for each block added
-	BlockCB BlockCB
+	NodeCB NodeCB
 }
 
 // Generate a new DagBuilderHelper from the given params, using 'in' as a
 // data source
 func (dbp *DagBuilderParams) New(in <-chan []byte) *DagBuilderHelper {
-	bcb := dbp.BlockCB
-	if bcb == nil {
-		bcb = nilFunc
+	ncb := dbp.NodeCB
+	if ncb == nil {
+		ncb = nilFunc
 	}
 
 	return &DagBuilderHelper{
 		dserv:    dbp.Dagserv,
 		in:       in,
 		maxlinks: dbp.Maxlinks,
-		bcb:      bcb,
+		ncb:      ncb,
 	}
 }
 
@@ -136,13 +135,13 @@ func (db *DagBuilderHelper) Add(node *UnixfsNode) (*dag.Node, error) {
 		return nil, err
 	}
 
-	key, err := db.dserv.Add(dn)
+	_, err = db.dserv.Add(dn)
 	if err != nil {
 		return nil, err
 	}
 
-	// block callback
-	err = db.bcb(key, true)
+	// node callback
+	err = db.ncb(dn, true)
 	if err != nil {
 		return nil, err
 	}

importer/helpers/helpers.go

@@ -107,13 +107,13 @@ func (n *UnixfsNode) AddChild(child *UnixfsNode, db *DagBuilderHelper) error {
 		return err
 	}
 
-	childkey, err := db.dserv.Add(childnode)
+	_, err = db.dserv.Add(childnode)
 	if err != nil {
 		return err
 	}
 
 	// Pin the child node indirectly
-	err = db.bcb(childkey, false)
+	err = db.ncb(childnode, false)
 	if err != nil {
 		return err
 	}

importer/importer.go

@@ -39,34 +39,39 @@ func BuildDagFromFile(fpath string, ds dag.DAGService, mp pin.ManualPinner) (*da
 	return BuildDagFromReader(f, ds, chunk.DefaultSplitter, BasicPinnerCB(mp))
 }
 
-func BuildDagFromReader(r io.Reader, ds dag.DAGService, spl chunk.BlockSplitter, bcb h.BlockCB) (*dag.Node, error) {
+func BuildDagFromReader(r io.Reader, ds dag.DAGService, spl chunk.BlockSplitter, ncb h.NodeCB) (*dag.Node, error) {
 	// Start the splitter
 	blkch := spl.Split(r)
 
 	dbp := h.DagBuilderParams{
 		Dagserv:  ds,
 		Maxlinks: h.DefaultLinksPerBlock,
-		BlockCB:  bcb,
+		NodeCB:   ncb,
 	}
 
 	return bal.BalancedLayout(dbp.New(blkch))
 }
 
-func BuildTrickleDagFromReader(r io.Reader, ds dag.DAGService, spl chunk.BlockSplitter, bcb h.BlockCB) (*dag.Node, error) {
+func BuildTrickleDagFromReader(r io.Reader, ds dag.DAGService, spl chunk.BlockSplitter, ncb h.NodeCB) (*dag.Node, error) {
 	// Start the splitter
 	blkch := spl.Split(r)
 
 	dbp := h.DagBuilderParams{
 		Dagserv:  ds,
 		Maxlinks: h.DefaultLinksPerBlock,
-		BlockCB:  bcb,
+		NodeCB:   ncb,
 	}
 
 	return trickle.TrickleLayout(dbp.New(blkch))
 }
 
-func BasicPinnerCB(p pin.ManualPinner) h.BlockCB {
-	return func(k u.Key, root bool) error {
+func BasicPinnerCB(p pin.ManualPinner) h.NodeCB {
+	return func(n *dag.Node, root bool) error {
+		k, err := n.Key()
+		if err != nil {
+			return err
+		}
+
 		if root {
 			p.PinWithMode(k, pin.Recursive)
 			return p.Flush()
@@ -77,8 +82,13 @@ func BasicPinnerCB(p pin.ManualPinner) h.BlockCB {
 	}
 }
 
-func PinIndirectCB(p pin.ManualPinner) h.BlockCB {
-	return func(k u.Key, root bool) error {
+func PinIndirectCB(p pin.ManualPinner) h.NodeCB {
+	return func(n *dag.Node, root bool) error {
+		k, err := n.Key()
+		if err != nil {
+			return err
+		}
+
 		p.PinWithMode(k, pin.Indirect)
 		return nil
 	}

unixfs/mod/dagmodifier.go

@@ -309,7 +309,7 @@ func (dm *DagModifier) appendData(node *mdag.Node, blks <-chan []byte) (*mdag.No
 	dbp := &help.DagBuilderParams{
 		Dagserv:  dm.dagserv,
 		Maxlinks: help.DefaultLinksPerBlock,
-		BlockCB:  imp.BasicPinnerCB(dm.mp),
+		NodeCB:   imp.BasicPinnerCB(dm.mp),
 	}
 
 	return trickle.TrickleAppend(node, dbp.New(blks))