implement ipfs pin update

License: MIT
Signed-off-by: Jeromy <[email protected]>

Author: whyrusleeping

core/commands/object/diff.go

@@ -7,7 +7,6 @@ import (
 
 	cmds "github.com/ipfs/go-ipfs/commands"
 	core "github.com/ipfs/go-ipfs/core"
-	dag "github.com/ipfs/go-ipfs/merkledag"
 	dagutils "github.com/ipfs/go-ipfs/merkledag/utils"
 	path "github.com/ipfs/go-ipfs/path"
 )
@@ -86,19 +85,7 @@ Example:
 			return
 		}
 
-		pbobj_a, ok := obj_a.(*dag.ProtoNode)
-		if !ok {
-			res.SetError(dag.ErrNotProtobuf, cmds.ErrNormal)
-			return
-		}
-
-		pbobj_b, ok := obj_b.(*dag.ProtoNode)
-		if !ok {
-			res.SetError(dag.ErrNotProtobuf, cmds.ErrNormal)
-			return
-		}
-
-		changes, err := dagutils.Diff(ctx, node.DAG, pbobj_a, pbobj_b)
+		changes, err := dagutils.Diff(ctx, node.DAG, obj_a, obj_b)
 		if err != nil {
 			res.SetError(err, cmds.ErrNormal)
 			return

core/commands/pin.go

@@ -24,9 +24,10 @@ var PinCmd = &cmds.Command{
 	},
 
 	Subcommands: map[string]*cmds.Command{
-		"add": addPinCmd,
-		"rm":  rmPinCmd,
-		"ls":  listPinCmd,
+		"add":    addPinCmd,
+		"rm":     rmPinCmd,
+		"ls":     listPinCmd,
+		"update": updatePinCmd,
 	},
 }
 
@@ -332,6 +333,83 @@ Example:
 	},
 }
 
+var updatePinCmd = &cmds.Command{
+	Helptext: cmds.HelpText{
+		Tagline: "Update a recursive pin",
+		ShortDescription: `
+Updates one pin to another, making sure that all objects in the new pin are
+local.  Then removes the old pin. This is an optimized version of adding the
+new pin and removing the old one.
+`,
+	},
+
+	Arguments: []cmds.Argument{
+		cmds.StringArg("from-path", true, false, "Path to old object."),
+		cmds.StringArg("to-path", true, false, "Path to new object to be pinned."),
+	},
+	Options: []cmds.Option{
+		cmds.BoolOption("unpin", "Remove the old pin.").Default(true),
+	},
+	Type: PinOutput{},
+	Run: func(req cmds.Request, res cmds.Response) {
+		n, err := req.InvocContext().GetNode()
+		if err != nil {
+			res.SetError(err, cmds.ErrNormal)
+			return
+		}
+
+		unpin, _, err := req.Option("unpin").Bool()
+		if err != nil {
+			res.SetError(err, cmds.ErrNormal)
+			return
+		}
+
+		from, err := path.ParsePath(req.Arguments()[0])
+		if err != nil {
+			res.SetError(err, cmds.ErrNormal)
+			return
+		}
+
+		to, err := path.ParsePath(req.Arguments()[1])
+		if err != nil {
+			res.SetError(err, cmds.ErrNormal)
+			return
+		}
+
+		fromc, err := core.ResolveToCid(req.Context(), n, from)
+		if err != nil {
+			res.SetError(err, cmds.ErrNormal)
+			return
+		}
+
+		toc, err := core.ResolveToCid(req.Context(), n, to)
+		if err != nil {
+			res.SetError(err, cmds.ErrNormal)
+			return
+		}
+
+		err = n.Pinning.Update(req.Context(), fromc, toc, unpin)
+		if err != nil {
+			res.SetError(err, cmds.ErrNormal)
+			return
+		}
+
+		res.SetOutput(&PinOutput{Pins: []string{from.String(), to.String()}})
+	},
+	Marshalers: cmds.MarshalerMap{
+		cmds.Text: func(res cmds.Response) (io.Reader, error) {
+			added, ok := res.Output().(*PinOutput)
+			if !ok {
+				return nil, u.ErrCast()
+			}
+
+			buf := new(bytes.Buffer)
+			fmt.Fprintf(buf, "updated %s to %s\n", added.Pins[0], added.Pins[1])
+			return buf, nil
+		},
+	},
+}
+
 type RefKeyObject struct {
 	Type string
 }

merkledag/merkledag.go

@@ -153,7 +153,7 @@ func (n *dagService) Remove(nd node.Node) error {
 // GetLinksDirect creates a function to get the links for a node, from
 // the node, bypassing the LinkService.  If the node does not exist
 // locally (and can not be retrieved) an error will be returned.
-func GetLinksDirect(serv DAGService) GetLinks {
+func GetLinksDirect(serv node.NodeGetter) GetLinks {
 	return func(ctx context.Context, c *cid.Cid) ([]*node.Link, error) {
 		node, err := serv.Get(ctx, c)
 		if err != nil {

merkledag/utils/diff.go

@@ -1,13 +1,14 @@
 package dagutils
 
 import (
+	"context"
 	"fmt"
 	"path"
 
 	dag "github.com/ipfs/go-ipfs/merkledag"
 
-	context "context"
 	cid "gx/ipfs/QmV5gPoRsjN1Gid3LMdNZTyfCtP2DsvqEbMAmz82RmmiGk/go-cid"
+	node "gx/ipfs/QmYDscK7dmdo2GZ9aumS8s5auUUAH5mR1jvj5pYhWusfK7/go-ipld-node"
 )
 
 const (
@@ -87,7 +88,7 @@ func ApplyChange(ctx context.Context, ds dag.DAGService, nd *dag.ProtoNode, cs [
 	return e.Finalize(ds)
 }
 
-func Diff(ctx context.Context, ds dag.DAGService, a, b *dag.ProtoNode) ([]*Change, error) {
+func Diff(ctx context.Context, ds dag.DAGService, a, b node.Node) ([]*Change, error) {
 	if len(a.Links()) == 0 && len(b.Links()) == 0 {
 		return []*Change{
 			&Change{
@@ -104,7 +105,7 @@ func Diff(ctx context.Context, ds dag.DAGService, a, b *dag.ProtoNode) ([]*Chang
 
 	// strip out unchanged stuff
 	for _, lnk := range a.Links() {
-		l, err := b.GetNodeLink(lnk.Name)
+		l, _, err := b.ResolveLink([]string{lnk.Name})
 		if err == nil {
 			if l.Cid.Equals(lnk.Cid) {
 				// no change... ignore it

merkledag/utils/diffenum.go

@@ -0,0 +1,75 @@
+package dagutils
+
+import (
+	"context"
+	"fmt"
+
+	mdag "github.com/ipfs/go-ipfs/merkledag"
+
+	cid "gx/ipfs/QmV5gPoRsjN1Gid3LMdNZTyfCtP2DsvqEbMAmz82RmmiGk/go-cid"
+	node "gx/ipfs/QmYDscK7dmdo2GZ9aumS8s5auUUAH5mR1jvj5pYhWusfK7/go-ipld-node"
+)
+
+// DiffEnumerate fetches every object in the graph pointed to by 'to' that is
+// not in 'from'. This can be used to more efficiently fetch a graph if you can
+// guarantee you already have the entirety of 'from'
+func DiffEnumerate(ctx context.Context, dserv node.NodeGetter, from, to *cid.Cid) error {
+	fnd, err := dserv.Get(ctx, from)
+	if err != nil {
+		return fmt.Errorf("get %s: %s", from, err)
+	}
+
+	tnd, err := dserv.Get(ctx, to)
+	if err != nil {
+		return fmt.Errorf("get %s: %s", to, err)
+	}
+
+	diff := getLinkDiff(fnd, tnd)
+
+	sset := cid.NewSet()
+	for _, c := range diff {
+		if c.a == nil {
+			err := mdag.EnumerateChildrenAsync(ctx, mdag.GetLinksDirect(dserv), c.b, sset.Visit)
+			if err != nil {
+				return err
+			}
+		} else {
+			err := DiffEnumerate(ctx, dserv, c.a, c.b)
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+
+type diffpair struct {
+	a, b *cid.Cid
+}
+
+func getLinkDiff(a, b node.Node) []diffpair {
+	have := make(map[string]*node.Link)
+	names := make(map[string]*node.Link)
+	for _, l := range a.Links() {
+		have[l.Cid.KeyString()] = l
+		names[l.Name] = l
+	}
+
+	var out []diffpair
+
+	for _, l := range b.Links() {
+		if have[l.Cid.KeyString()] != nil {
+			continue
+		}
+
+		match, ok := names[l.Name]
+		if !ok {
+			out = append(out, diffpair{b: l.Cid})
+			continue
+		}
+
+		out = append(out, diffpair{a: match.Cid, b: l.Cid})
+	}
+	return out
+}

merkledag/utils/diffenum_test.go

@@ -0,0 +1,149 @@
+package dagutils
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	dag "github.com/ipfs/go-ipfs/merkledag"
+	mdtest "github.com/ipfs/go-ipfs/merkledag/test"
+
+	cid "gx/ipfs/QmV5gPoRsjN1Gid3LMdNZTyfCtP2DsvqEbMAmz82RmmiGk/go-cid"
+	node "gx/ipfs/QmYDscK7dmdo2GZ9aumS8s5auUUAH5mR1jvj5pYhWusfK7/go-ipld-node"
+)
+
+func buildNode(name string, desc map[string]ndesc, out map[string]node.Node) node.Node {
+	this := desc[name]
+	nd := new(dag.ProtoNode)
+	nd.SetData([]byte(name))
+	for k, v := range this {
+		child, ok := out[v]
+		if !ok {
+			child = buildNode(v, desc, out)
+			out[v] = child
+		}
+
+		if err := nd.AddNodeLink(k, child); err != nil {
+			panic(err)
+		}
+	}
+
+	return nd
+}
+
+type ndesc map[string]string
+
+func mkGraph(desc map[string]ndesc) map[string]node.Node {
+	out := make(map[string]node.Node)
+	for name, _ := range desc {
+		if _, ok := out[name]; ok {
+			continue
+		}
+
+		out[name] = buildNode(name, desc, out)
+	}
+	return out
+}
+
+var tg1 = map[string]ndesc{
+	"a1": ndesc{
+		"foo": "b",
+	},
+	"b": ndesc{},
+	"a2": ndesc{
+		"foo": "b",
+		"bar": "c",
+	},
+	"c": ndesc{},
+}
+
+var tg2 = map[string]ndesc{
+	"a1": ndesc{
+		"foo": "b",
+	},
+	"b": ndesc{},
+	"a2": ndesc{
+		"foo": "b",
+		"bar": "c",
+	},
+	"c": ndesc{"baz": "d"},
+	"d": ndesc{},
+}
+
+func TestDiffEnumBasic(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	nds := mkGraph(tg1)
+
+	ds := mdtest.Mock()
+	lgds := &getLogger{ds: ds}
+
+	for _, nd := range nds {
+		_, err := ds.Add(nd)
+		if err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	err := DiffEnumerate(ctx, lgds, nds["a1"].Cid(), nds["a2"].Cid())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = assertCidList(lgds.log, []*cid.Cid{nds["a1"].Cid(), nds["a2"].Cid(), nds["c"].Cid()})
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+type getLogger struct {
+	ds  node.NodeGetter
+	log []*cid.Cid
+}
+
+func (gl *getLogger) Get(ctx context.Context, c *cid.Cid) (node.Node, error) {
+	nd, err := gl.ds.Get(ctx, c)
+	if err != nil {
+		return nil, err
+	}
+	gl.log = append(gl.log, c)
+	return nd, nil
+}
+
+func assertCidList(a, b []*cid.Cid) error {
+	if len(a) != len(b) {
+		return fmt.Errorf("got different number of cids than expected")
+	}
+	for i, c := range a {
+		if !c.Equals(b[i]) {
+			return fmt.Errorf("expected %s, got %s", c, b[i])
+		}
+	}
+	return nil
+}
+func TestDiffEnumFail(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	nds := mkGraph(tg2)
+
+	ds := mdtest.Mock()
+	lgds := &getLogger{ds: ds}
+
+	for _, s := range []string{"a1", "a2", "b", "c"} {
+		_, err := ds.Add(nds[s])
+		if err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	err := DiffEnumerate(ctx, lgds, nds["a1"].Cid(), nds["a2"].Cid())
+	if err != dag.ErrNotFound {
+		t.Fatal("expected err not found")
+	}
+
+	err = assertCidList(lgds.log, []*cid.Cid{nds["a1"].Cid(), nds["a2"].Cid(), nds["c"].Cid()})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+}