implement an ipfs patch command for modifying merkledag objects

WIP: object creator command

better docs

move patch command into object namespace

dont ignore cancel funcs

addressing comment from CR

add two new subcommands to object patch and clean up main Run func

cancel contexts in early returns

switch to util.Key

core/commands/object.go

@@ -9,13 +9,18 @@ import (
 	"io/ioutil"
 	"strings"
 	"text/tabwriter"
+	"time"
 
 	mh "github.com/ipfs/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multihash"
+	context "github.com/ipfs/go-ipfs/Godeps/_workspace/src/golang.org/x/net/context"
 
+	key "github.com/ipfs/go-ipfs/blocks/key"
 	cmds "github.com/ipfs/go-ipfs/commands"
 	core "github.com/ipfs/go-ipfs/core"
 	dag "github.com/ipfs/go-ipfs/merkledag"
 	path "github.com/ipfs/go-ipfs/path"
+	ft "github.com/ipfs/go-ipfs/unixfs"
+	u "github.com/ipfs/go-ipfs/util"
 )
 
 // ErrObjectTooLarge is returned when too much data was read from stdin. current limit 512k
@@ -45,11 +50,13 @@ var ObjectCmd = &cmds.Command{
 'ipfs object' is a plumbing command used to manipulate DAG objects
 directly.`,
 		Synopsis: `
-ipfs object get <key>   - Get the DAG node named by <key>
-ipfs object put <data>  - Stores input, outputs its key
-ipfs object data <key>  - Outputs raw bytes in an object
-ipfs object links <key> - Outputs links pointed to by object
-ipfs object stat <key>  - Outputs statistics of object
+ipfs object get <key>       - Get the DAG node named by <key>
+ipfs object put <data>      - Stores input, outputs its key
+ipfs object data <key>      - Outputs raw bytes in an object
+ipfs object links <key>     - Outputs links pointed to by object
+ipfs object stat <key>      - Outputs statistics of object
+ipfs object new <template>  - Create new ipfs objects
+ipfs object patch <args>    - Create new object from old ones
 `,
 	},
 
@@ -59,6 +66,8 @@ ipfs object stat <key>  - Outputs statistics of object
 		"get":   objectGetCmd,
 		"put":   objectPutCmd,
 		"stat":  objectStatCmd,
+		"new":   objectNewCmd,
+		"patch": objectPatchCmd,
 	},
 }
 
@@ -348,6 +357,274 @@ Data should be in the format specified by the --inputenc flag.
 	Type: Object{},
 }
 
+var objectNewCmd = &cmds.Command{
+	Helptext: cmds.HelpText{
+		Tagline: "creates a new object from an ipfs template",
+		ShortDescription: `
+'ipfs object new' is a plumbing command for creating new DAG nodes.
+`,
+		LongDescription: `
+'ipfs object new' is a plumbing command for creating new DAG nodes.
+By default it creates and returns a new empty merkledag node, but
+you may pass an optional template argument to create a preformatted
+node.
+`,
+	},
+	Arguments: []cmds.Argument{
+		cmds.StringArg("template", false, false, "optional template to use"),
+	},
+	Run: func(req cmds.Request, res cmds.Response) {
+		n, err := req.Context().GetNode()
+		if err != nil {
+			res.SetError(err, cmds.ErrNormal)
+			return
+		}
+
+		node := new(dag.Node)
+		if len(req.Arguments()) == 1 {
+			template := req.Arguments()[0]
+			var err error
+			node, err = nodeFromTemplate(template)
+			if err != nil {
+				res.SetError(err, cmds.ErrNormal)
+				return
+			}
+		}
+
+		k, err := n.DAG.Add(node)
+		if err != nil {
+			res.SetError(err, cmds.ErrNormal)
+			return
+		}
+		res.SetOutput(&Object{Hash: k.B58String()})
+	},
+	Marshalers: cmds.MarshalerMap{
+		cmds.Text: func(res cmds.Response) (io.Reader, error) {
+			object := res.Output().(*Object)
+			return strings.NewReader(object.Hash + "\n"), nil
+		},
+	},
+	Type: Object{},
+}
+
+var objectPatchCmd = &cmds.Command{
+	Helptext: cmds.HelpText{
+		Tagline: "Create a new merkledag object based on an existing one",
+		ShortDescription: `
+'ipfs patch <root> [add-link|rm-link] <args>' is a plumbing command used to
+build custom DAG objects. It adds and removes links from objects, creating a new
+object as a result. This is the merkle-dag version of modifying an object.
+
+Examples:
+
+    EMPTY_DIR=$(ipfs object new unixfs-dir)
+    BAR=$(echo "bar" | ipfs add -q)
+    ipfs patch $EMPTY_DIR add-link foo $BAR
+
+This takes an empty directory, and adds a link named foo under it, pointing to
+a file containing 'bar', and returns the hash of the new object.
+
+    ipfs patch $FOO_BAR rm-link foo
+
+This removes the link named foo from the hash in $FOO_BAR and returns the
+resulting object hash.
+`,
+	},
+	Options: []cmds.Option{},
+	Arguments: []cmds.Argument{
+		cmds.StringArg("root", true, false, "the hash of the node to modify"),
+		cmds.StringArg("command", true, false, "the operation to perform"),
+		cmds.StringArg("args", true, true, "extra arguments").EnableStdin(),
+	},
+	Type: key.Key(""),
+	Run: func(req cmds.Request, res cmds.Response) {
+		nd, err := req.Context().GetNode()
+		if err != nil {
+			res.SetError(err, cmds.ErrNormal)
+			return
+		}
+
+		rhash := key.B58KeyDecode(req.Arguments()[0])
+		if rhash == "" {
+			res.SetError(fmt.Errorf("incorrectly formatted root hash"), cmds.ErrNormal)
+			return
+		}
+
+		ctx, cancel := context.WithTimeout(req.Context().Context, time.Second*30)
+		rnode, err := nd.DAG.Get(ctx, rhash)
+		if err != nil {
+			res.SetError(err, cmds.ErrNormal)
+			cancel()
+			return
+		}
+		cancel()
+
+		action := req.Arguments()[1]
+
+		switch action {
+		case "add-link":
+			k, err := addLinkCaller(req, rnode)
+			if err != nil {
+				res.SetError(err, cmds.ErrNormal)
+				return
+			}
+			res.SetOutput(k)
+		case "rm-link":
+			k, err := rmLinkCaller(req, rnode)
+			if err != nil {
+				res.SetError(err, cmds.ErrNormal)
+				return
+			}
+			res.SetOutput(k)
+		case "set-data":
+			k, err := setDataCaller(req, rnode)
+			if err != nil {
+				res.SetError(err, cmds.ErrNormal)
+				return
+			}
+			res.SetOutput(k)
+		case "append-data":
+			k, err := appendDataCaller(req, rnode)
+			if err != nil {
+				res.SetError(err, cmds.ErrNormal)
+				return
+			}
+			res.SetOutput(k)
+		default:
+			res.SetError(fmt.Errorf("unrecognized subcommand"), cmds.ErrNormal)
+			return
+		}
+	},
+	Marshalers: cmds.MarshalerMap{
+		cmds.Text: func(res cmds.Response) (io.Reader, error) {
+			k, ok := res.Output().(key.Key)
+			if !ok {
+				return nil, u.ErrCast()
+			}
+
+			return strings.NewReader(k.B58String() + "\n"), nil
+		},
+	},
+}
+
+func appendDataCaller(req cmds.Request, root *dag.Node) (key.Key, error) {
+	if len(req.Arguments()) < 3 {
+		return "", fmt.Errorf("not enough arguments for set-data")
+	}
+
+	nd, err := req.Context().GetNode()
+	if err != nil {
+		return "", err
+	}
+
+	root.Data = append(root.Data, []byte(req.Arguments()[2])...)
+
+	newkey, err := nd.DAG.Add(root)
+	if err != nil {
+		return "", err
+	}
+
+	return newkey, nil
+}
+
+func setDataCaller(req cmds.Request, root *dag.Node) (key.Key, error) {
+	if len(req.Arguments()) < 3 {
+		return "", fmt.Errorf("not enough arguments for set-data")
+	}
+
+	nd, err := req.Context().GetNode()
+	if err != nil {
+		return "", err
+	}
+
+	root.Data = []byte(req.Arguments()[2])
+
+	newkey, err := nd.DAG.Add(root)
+	if err != nil {
+		return "", err
+	}
+
+	return newkey, nil
+}
+
+func rmLinkCaller(req cmds.Request, root *dag.Node) (key.Key, error) {
+	if len(req.Arguments()) < 3 {
+		return "", fmt.Errorf("not enough arguments for rm-link")
+	}
+
+	nd, err := req.Context().GetNode()
+	if err != nil {
+		return "", err
+	}
+
+	name := req.Arguments()[2]
+
+	err = root.RemoveNodeLink(name)
+	if err != nil {
+		return "", err
+	}
+
+	newkey, err := nd.DAG.Add(root)
+	if err != nil {
+		return "", err
+	}
+
+	return newkey, nil
+}
+
+func addLinkCaller(req cmds.Request, root *dag.Node) (key.Key, error) {
+	if len(req.Arguments()) < 4 {
+		return "", fmt.Errorf("not enough arguments for add-link")
+	}
+
+	nd, err := req.Context().GetNode()
+	if err != nil {
+		return "", err
+	}
+
+	name := req.Arguments()[2]
+	childk := key.B58KeyDecode(req.Arguments()[3])
+
+	newkey, err := addLink(req.Context().Context, nd.DAG, root, name, childk)
+	if err != nil {
+		return "", err
+	}
+
+	return newkey, nil
+}
+
+func addLink(ctx context.Context, ds dag.DAGService, root *dag.Node, childname string, childk key.Key) (key.Key, error) {
+	ctx, cancel := context.WithTimeout(ctx, time.Second*30)
+	childnd, err := ds.Get(ctx, childk)
+	if err != nil {
+		cancel()
+		return "", err
+	}
+	cancel()
+
+	err = root.AddNodeLinkClean(childname, childnd)
+	if err != nil {
+		return "", err
+	}
+
+	newkey, err := ds.Add(root)
+	if err != nil {
+		return "", err
+	}
+	return newkey, nil
+}
+
+func nodeFromTemplate(template string) (*dag.Node, error) {
+	switch template {
+	case "unixfs-dir":
+		nd := new(dag.Node)
+		nd.Data = ft.FolderPBData()
+		return nd, nil
+	default:
+		return nil, fmt.Errorf("template '%s' not found", template)
+	}
+}
+
 // ErrEmptyNode is returned when the input to 'ipfs object put' contains no data
 var ErrEmptyNode = errors.New("no data or links in this node")
 

routing/record/record.go

@@ -6,11 +6,13 @@ import (
 	proto "github.com/ipfs/go-ipfs/Godeps/_workspace/src/github.com/gogo/protobuf/proto"
 
 	key "github.com/ipfs/go-ipfs/blocks/key"
+	dag "github.com/ipfs/go-ipfs/merkledag"
 	ci "github.com/ipfs/go-ipfs/p2p/crypto"
 	pb "github.com/ipfs/go-ipfs/routing/dht/pb"
 	eventlog "github.com/ipfs/go-ipfs/thirdparty/eventlog"
 )
 
+var _ = dag.FetchGraph
 var log = eventlog.Logger("routing/record")
 
 // MakePutRecord creates and signs a dht record for the given key/value pair