original commands to original dir

core/commands/add.go

+package commands
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+
+	"github.com/jbenet/go-ipfs/core"
+	"github.com/jbenet/go-ipfs/importer"
+	dag "github.com/jbenet/go-ipfs/merkledag"
+	ft "github.com/jbenet/go-ipfs/unixfs"
+)
+
+// Error indicating the max depth has been exceded.
+var ErrDepthLimitExceeded = fmt.Errorf("depth limit exceeded")
+
+// Add is a command that imports files and directories -- given as arguments -- into ipfs.
+func Add(n *core.IpfsNode, args []string, opts map[string]interface{}, out io.Writer) error {
+	depth := 1
+
+	// if recursive, set depth to reflect so
+	if r, ok := opts["r"].(bool); r && ok {
+		depth = -1
+	}
+
+	// add every path in args
+	for _, path := range args {
+
+		// Add the file
+		_, err := AddPath(n, path, depth, out)
+		if err != nil {
+			if err == ErrDepthLimitExceeded && depth == 1 {
+				err = errors.New("use -r to recursively add directories")
+			}
+			return fmt.Errorf("addFile error: %v", err)
+		}
+
+	}
+	return nil
+}
+
+// AddPath adds a particular path to ipfs.
+func AddPath(n *core.IpfsNode, fpath string, depth int, out io.Writer) (*dag.Node, error) {
+	if depth == 0 {
+		return nil, ErrDepthLimitExceeded
+	}
+
+	fi, err := os.Stat(fpath)
+	if err != nil {
+		return nil, err
+	}
+
+	if fi.IsDir() {
+		return addDir(n, fpath, depth, out)
+	}
+
+	return addFile(n, fpath, depth, out)
+}
+
+func addDir(n *core.IpfsNode, fpath string, depth int, out io.Writer) (*dag.Node, error) {
+	tree := &dag.Node{Data: ft.FolderPBData()}
+
+	files, err := ioutil.ReadDir(fpath)
+	if err != nil {
+		return nil, err
+	}
+
+	// construct nodes for containing files.
+	for _, f := range files {
+		fp := filepath.Join(fpath, f.Name())
+		nd, err := AddPath(n, fp, depth-1, out)
+		if err != nil {
+			return nil, err
+		}
+
+		if err = tree.AddNodeLink(f.Name(), nd); err != nil {
+			return nil, err
+		}
+	}
+
+	log.Info("adding dir: %s", fpath)
+
+	return tree, addNode(n, tree, fpath, out)
+}
+
+func addFile(n *core.IpfsNode, fpath string, depth int, out io.Writer) (*dag.Node, error) {
+	root, err := importer.NewDagFromFile(fpath)
+	if err != nil {
+		return nil, err
+	}
+
+	log.Info("adding file: %s", fpath)
+
+	for _, l := range root.Links {
+		log.Info("adding subblock: %s %s", l.Name, l.Hash.B58String())
+	}
+
+	return root, addNode(n, root, fpath, out)
+}
+
+// addNode adds the node to the graph + local storage
+func addNode(n *core.IpfsNode, nd *dag.Node, fpath string, out io.Writer) error {
+	// add the file to the graph + local storage
+	err := n.DAG.AddRecursive(nd)
+	if err != nil {
+		return err
+	}
+
+	k, err := nd.Key()
+	if err != nil {
+		return err
+	}
+
+	// output that we've added this node
+	fmt.Fprintf(out, "added %s %s\n", k, fpath)
+
+	// ensure we keep it
+	return n.Pinning.Pin(nd, true)
+}

core/commands/block.go

+package commands
+
+import (
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"time"
+
+	"code.google.com/p/go.net/context"
+
+	mh "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multihash"
+	"github.com/jbenet/go-ipfs/blocks"
+	"github.com/jbenet/go-ipfs/core"
+	u "github.com/jbenet/go-ipfs/util"
+)
+
+// BlockGet retrives a raw ipfs block from the node's BlockService
+func BlockGet(n *core.IpfsNode, args []string, opts map[string]interface{}, out io.Writer) error {
+
+	if !u.IsValidHash(args[0]) {
+		return fmt.Errorf("block get: not a valid hash")
+	}
+
+	h, err := mh.FromB58String(args[0])
+	if err != nil {
+		return fmt.Errorf("block get: %v", err)
+	}
+
+	k := u.Key(h)
+	log.Debug("BlockGet key: '%q'", k)
+	ctx, _ := context.WithTimeout(context.TODO(), time.Second*5)
+	b, err := n.Blocks.GetBlock(ctx, k)
+	if err != nil {
+		return fmt.Errorf("block get: %v", err)
+	}
+
+	_, err = out.Write(b.Data)
+	return err
+}
+
+// BlockPut reads everything from conn and saves the data to the nodes BlockService
+func BlockPut(n *core.IpfsNode, args []string, opts map[string]interface{}, out io.Writer) error {
+	// TODO: this should read from an io.Reader arg
+	data, err := ioutil.ReadAll(os.Stdin)
+	if err != nil {
+		return err
+	}
+
+	b := blocks.NewBlock(data)
+	log.Debug("BlockPut key: '%q'", b.Key())
+
+	k, err := n.Blocks.AddBlock(b)
+	if err != nil {
+		return err
+	}
+	fmt.Fprintf(out, "added as '%s'\n", k)
+
+	return nil
+}

core/commands/cat.go

+package commands
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/jbenet/go-ipfs/core"
+	uio "github.com/jbenet/go-ipfs/unixfs/io"
+)
+
+func Cat(n *core.IpfsNode, args []string, opts map[string]interface{}, out io.Writer) error {
+	for _, fn := range args {
+		dagnode, err := n.Resolver.ResolvePath(fn)
+		if err != nil {
+			return fmt.Errorf("catFile error: %v", err)
+		}
+
+		read, err := uio.NewDagReader(dagnode, n.DAG)
+		if err != nil {
+			return fmt.Errorf("cat error: %v", err)
+		}
+
+		_, err = io.Copy(out, read)
+		if err != nil {
+			return fmt.Errorf("cat error: %v", err)
+		}
+	}
+	return nil
+}

core/commands/commands.go

+package commands
+
+import (
+	"io"
+
+	"github.com/jbenet/go-ipfs/core"
+	u "github.com/jbenet/go-ipfs/util"
+)
+
+var log = u.Logger("commands")
+
+type CmdFunc func(*core.IpfsNode, []string, map[string]interface{}, io.Writer) error

core/commands/diag.go

+package commands
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"time"
+
+	"github.com/jbenet/go-ipfs/core"
+	diagn "github.com/jbenet/go-ipfs/diagnostics"
+)
+
+func PrintDiagnostics(info []*diagn.DiagInfo, out io.Writer) {
+	for _, i := range info {
+		fmt.Fprintf(out, "Peer: %s\n", i.ID)
+		fmt.Fprintf(out, "\tUp for: %s\n", i.LifeSpan.String())
+		fmt.Fprintf(out, "\tConnected To:\n")
+		for _, c := range i.Connections {
+			fmt.Fprintf(out, "\t%s\n\t\tLatency = %s\n", c.ID, c.Latency.String())
+		}
+		fmt.Fprintln(out)
+	}
+
+}
+
+func Diag(n *core.IpfsNode, args []string, opts map[string]interface{}, out io.Writer) error {
+	if n.Diagnostics == nil {
+		return errors.New("Cannot run diagnostic in offline mode!")
+	}
+	info, err := n.Diagnostics.GetDiagnostic(time.Second * 20)
+	if err != nil {
+		return err
+	}
+	raw, ok := opts["raw"].(bool)
+	if !ok {
+		return errors.New("incorrect value to parameter 'raw'")
+	}
+	if raw {
+		enc := json.NewEncoder(out)
+		err = enc.Encode(info)
+		if err != nil {
+			return err
+		}
+	} else {
+		PrintDiagnostics(info, out)
+	}
+	return nil
+}

core/commands/log.go

+package commands
+
+import (
+	"io"
+
+	"github.com/jbenet/go-ipfs/core"
+	u "github.com/jbenet/go-ipfs/util"
+)
+
+// Log changes the log level of a subsystem
+func Log(n *core.IpfsNode, args []string, opts map[string]interface{}, out io.Writer) error {
+	if err := u.SetLogLevel(args[0], args[1]); err != nil {
+		return err
+	}
+
+	log.Info("Changed LogLevel of %q to %q", args[0], args[1])
+	return nil
+}

core/commands/ls.go

+package commands
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/jbenet/go-ipfs/core"
+)
+
+func Ls(n *core.IpfsNode, args []string, opts map[string]interface{}, out io.Writer) error {
+	for _, fn := range args {
+		dagnode, err := n.Resolver.ResolvePath(fn)
+		if err != nil {
+			return fmt.Errorf("ls error: %v", err)
+		}
+
+		for _, link := range dagnode.Links {
+			fmt.Fprintf(out, "%s %d %s\n", link.Hash.B58String(), link.Size, link.Name)
+		}
+	}
+	return nil
+}

core/commands/object.go

+package commands
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+
+	"github.com/jbenet/go-ipfs/core"
+	dag "github.com/jbenet/go-ipfs/merkledag"
+)
+
+// ObjectData takes a key string from args and writes out the raw bytes of that node (if there is one)
+func ObjectData(n *core.IpfsNode, args []string, opts map[string]interface{}, out io.Writer) error {
+	dagnode, err := n.Resolver.ResolvePath(args[0])
+	if err != nil {
+		return fmt.Errorf("objectData error: %v", err)
+	}
+	log.Debug("objectData: found dagnode %q (# of bytes: %d - # links: %d)", args[0], len(dagnode.Data), len(dagnode.Links))
+
+	_, err = io.Copy(out, bytes.NewReader(dagnode.Data))
+	return err
+}
+
+// ObjectLinks takes a key string from args and lists the links it points to
+func ObjectLinks(n *core.IpfsNode, args []string, opts map[string]interface{}, out io.Writer) error {
+	dagnode, err := n.Resolver.ResolvePath(args[0])
+	if err != nil {
+		return fmt.Errorf("objectLinks error: %v", err)
+	}
+	log.Debug("ObjectLinks: found dagnode %q (# of bytes: %d - # links: %d)", args[0], len(dagnode.Data), len(dagnode.Links))
+
+	for _, link := range dagnode.Links {
+		_, err = fmt.Fprintf(out, "%s %d %q\n", link.Hash.B58String(), link.Size, link.Name)
+		if err != nil {
+			break
+		}
+	}
+
+	return err
+}
+
+// ErrUnknownObjectEnc is returned if a invalid encoding is supplied
+var ErrUnknownObjectEnc = errors.New("unknown object encoding")
+
+type objectEncoding string
+
+const (
+	objectEncodingJSON     objectEncoding = "json"
+	objectEncodingProtobuf                = "protobuf"
+)
+
+func getObjectEnc(o interface{}) objectEncoding {
+	v, ok := o.(string)
+	if !ok {
+		// chosen as default because it's human readable
+		log.Warning("option is not a string - falling back to json")
+		return objectEncodingJSON
+	}
+
+	return objectEncoding(v)
+}
+
+// ObjectGet takes a key string from args and a format option and serializes the dagnode to that format
+func ObjectGet(n *core.IpfsNode, args []string, opts map[string]interface{}, out io.Writer) error {
+	dagnode, err := n.Resolver.ResolvePath(args[0])
+	if err != nil {
+		return fmt.Errorf("ObjectGet error: %v", err)
+	}
+	log.Debug("objectGet: found dagnode %q (# of bytes: %d - # links: %d)", args[0], len(dagnode.Data), len(dagnode.Links))
+
+	// sadly all encodings dont implement a common interface
+	var data []byte
+	switch getObjectEnc(opts["encoding"]) {
+	case objectEncodingJSON:
+		data, err = json.MarshalIndent(dagnode, "", "  ")
+
+	case objectEncodingProtobuf:
+		data, err = dagnode.Marshal()
+
+	default:
+		return ErrUnknownObjectEnc
+	}
+
+	if err != nil {
+		return fmt.Errorf("ObjectGet error: %v", err)
+	}
+
+	_, err = io.Copy(out, bytes.NewReader(data))
+	return err
+}
+
+// ErrObjectTooLarge is returned when too much data was read from stdin. current limit 512k
+var ErrObjectTooLarge = errors.New("input object was too large. limit is 512kbytes")
+
+const inputLimit = 512 * 1024
+
+// ObjectPut takes a format option, serilizes bytes from stdin and updates the dag with that data
+func ObjectPut(n *core.IpfsNode, args []string, opts map[string]interface{}, out io.Writer) error {
+	var (
+		dagnode *dag.Node
+		data    []byte
+		err     error
+	)
+
+	data, err = ioutil.ReadAll(io.LimitReader(os.Stdin, inputLimit+10))
+	if err != nil {
+		return fmt.Errorf("ObjectPut error: %v", err)
+	}
+
+	if len(data) >= inputLimit {
+		return ErrObjectTooLarge
+	}
+
+	switch getObjectEnc(opts["encoding"]) {
+	case objectEncodingJSON:
+		dagnode = new(dag.Node)
+		err = json.Unmarshal(data, dagnode)
+
+	case objectEncodingProtobuf:
+		dagnode, err = dag.Decoded(data)
+
+	default:
+		return ErrUnknownObjectEnc
+	}
+
+	if err != nil {
+		return fmt.Errorf("ObjectPut error: %v", err)
+	}
+
+	return addNode(n, dagnode, "stdin", out)
+}

core/commands/pin.go

+package commands
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/jbenet/go-ipfs/core"
+)
+
+func Pin(n *core.IpfsNode, args []string, opts map[string]interface{}, out io.Writer) error {
+
+	// set recursive flag
+	recursive, _ := opts["r"].(bool) // false if cast fails.
+
+	// if recursive, set depth flag
+	depth := 1 // default (non recursive)
+	if d, ok := opts["d"].(int); recursive && ok {
+		depth = d
+	}
+	if depth < -1 {
+		return fmt.Errorf("ipfs pin: called with invalid depth: %v", depth)
+	}
+
+	fmt.Printf("recursive, depth: %v, %v\n", recursive, depth)
+
+	for _, fn := range args {
+		dagnode, err := n.Resolver.ResolvePath(fn)
+		if err != nil {
+			return fmt.Errorf("pin error: %v", err)
+		}
+
+		err = n.Pinning.Pin(dagnode, recursive)
+		if err != nil {
+			return fmt.Errorf("pin: %v", err)
+		}
+	}
+	return n.Pinning.Flush()
+}
+
+func Unpin(n *core.IpfsNode, args []string, opts map[string]interface{}, out io.Writer) error {
+
+	// set recursive flag
+	recursive, _ := opts["r"].(bool) // false if cast fails.
+
+	for _, fn := range args {
+		dagnode, err := n.Resolver.ResolvePath(fn)
+		if err != nil {
+			return fmt.Errorf("pin error: %v", err)
+		}
+
+		k, _ := dagnode.Key()
+		err = n.Pinning.Unpin(k, recursive)
+		if err != nil {
+			return fmt.Errorf("pin: %v", err)
+		}
+	}
+	return n.Pinning.Flush()
+}

core/commands/publish.go

+package commands
+
+import (
+	"errors"
+	"fmt"
+	"io"
+
+	"github.com/jbenet/go-ipfs/core"
+	u "github.com/jbenet/go-ipfs/util"
+
+	nsys "github.com/jbenet/go-ipfs/namesys"
+)
+
+func Publish(n *core.IpfsNode, args []string, opts map[string]interface{}, out io.Writer) error {
+	log.Debug("Begin Publish")
+
+	if n.Identity == nil {
+		return errors.New("Identity not loaded!")
+	}
+
+	// name := ""
+	ref := ""
+
+	switch len(args) {
+	case 2:
+		// name = args[0]
+		ref = args[1]
+		return errors.New("keychains not yet implemented")
+	case 1:
+		// name = n.Identity.ID.String()
+		ref = args[0]
+
+	default:
+		return fmt.Errorf("Publish expects 1 or 2 args; got %d.", len(args))
+	}
+
+	// later, n.Keychain.Get(name).PrivKey
+	k := n.Identity.PrivKey()
+
+	pub := nsys.NewRoutingPublisher(n.Routing)
+	err := pub.Publish(k, ref)
+	if err != nil {
+		return err
+	}
+
+	hash, err := k.GetPublic().Hash()
+	if err != nil {
+		return err
+	}
+	fmt.Fprintf(out, "published name %s to %s\n", u.Key(hash), ref)
+
+	return nil
+}

core/commands/refs.go

+package commands
+
+import (
+	"io"
+
+	mh "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multihash"
+	"github.com/jbenet/go-ipfs/core"
+	mdag "github.com/jbenet/go-ipfs/merkledag"
+	u "github.com/jbenet/go-ipfs/util"
+)
+
+func Refs(n *core.IpfsNode, args []string, opts map[string]interface{}, out io.Writer) error {
+	unique, ok := opts["u"].(bool)
+	if !ok {
+		unique = false
+	}
+
+	recursive, ok := opts["r"].(bool)
+	if !ok {
+		recursive = false
+	}
+
+	var refsSeen map[u.Key]bool
+	if unique {
+		refsSeen = make(map[u.Key]bool)
+	}
+
+	for _, fn := range args {
+		nd, err := n.Resolver.ResolvePath(fn)
+		if err != nil {
+			return err
+		}
+
+		printRefs(n, nd, refsSeen, recursive)
+	}
+	return nil
+}
+
+func printRefs(n *core.IpfsNode, nd *mdag.Node, refSeen map[u.Key]bool, recursive bool) {
+	for _, link := range nd.Links {
+		printRef(link.Hash, refSeen)
+
+		if recursive {
+			nd, err := n.DAG.Get(u.Key(link.Hash))
+			if err != nil {
+				log.Errorf("error: cannot retrieve %s (%s)", link.Hash.B58String(), err)
+				return
+			}
+
+			printRefs(n, nd, refSeen, recursive)
+		}
+	}
+}
+
+func printRef(h mh.Multihash, refsSeen map[u.Key]bool) {
+	if refsSeen != nil {
+		_, found := refsSeen[u.Key(h)]
+		if found {
+			return
+		}
+		refsSeen[u.Key(h)] = true
+	}
+
+	u.POut("%s\n", h.B58String())
+}

core/commands/resolve.go

+package commands
+
+import (
+	"errors"
+	"fmt"
+	"io"
+
+	"github.com/jbenet/go-ipfs/core"
+)
+
+func Resolve(n *core.IpfsNode, args []string, opts map[string]interface{}, out io.Writer) error {
+
+	name := ""
+
+	switch len(args) {
+	case 1:
+		name = args[0]
+	case 0:
+		if n.Identity == nil {
+			return errors.New("Identity not loaded!")
+		}
+		name = n.Identity.ID().String()
+
+	default:
+		return fmt.Errorf("Publish expects 1 or 2 args; got %d.", len(args))
+	}
+
+	res, err := n.Namesys.Resolve(name)
+	if err != nil {
+		return err
+	}
+
+	fmt.Fprintf(out, "%s\n", res)
+	return nil
+}

core/commands/update.go

+package commands
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"os"
+
+	"github.com/jbenet/go-ipfs/core"
+	"github.com/jbenet/go-ipfs/updates"
+)
+
+// UpdateApply applys an update of the ipfs binary and shuts down the node if successful
+func UpdateApply(n *core.IpfsNode, args []string, opts map[string]interface{}, out io.Writer) error {
+	fmt.Fprintln(out, "Current Version:", updates.Version)
+	u, err := updates.CheckForUpdate()
+	if err != nil {
+		return err
+	}
+
+	if u == nil {
+		fmt.Fprintln(out, "No update available")
+		return nil
+	}
+	fmt.Fprintln(out, "New Version:", u.Version)
+
+	_, onDaemon := opts["onDaemon"]
+	force := opts["force"].(bool)
+	if onDaemon && !force {
+		return fmt.Errorf(`Error: update must stop running ipfs service.
+You may want to abort the update, or shut the service down manually.
+To shut it down automatically, run:
+
+  ipfs update --force
+`)
+	}
+
+	if err = updates.Apply(u); err != nil {
+		fmt.Fprint(out, err.Error())
+		return fmt.Errorf("Couldn't apply update: %v", err)
+	}
+
+	fmt.Fprintln(out, "Updated applied!")
+	if onDaemon {
+		if force {
+			fmt.Fprintln(out, "Shutting down ipfs service.")
+			os.Exit(1) // is there a cleaner shutdown routine?
+		} else {
+			fmt.Fprintln(out, "You can now restart the ipfs service.")
+		}
+	}
+
+	return nil
+}
+
+// UpdateCheck checks wether there is an update available
+func UpdateCheck(n *core.IpfsNode, args []string, opts map[string]interface{}, out io.Writer) error {
+	fmt.Fprintln(out, "Current Version:", updates.Version)
+	u, err := updates.CheckForUpdate()
+	if err != nil {
+		return err
+	}
+
+	if u == nil {
+		fmt.Fprintln(out, "No update available")
+		return nil
+	}
+
+	fmt.Fprintln(out, "New Version:", u.Version)
+	return nil
+}
+
+// UpdateLog lists the version available online
+func UpdateLog(n *core.IpfsNode, args []string, opts map[string]interface{}, out io.Writer) error {
+	return errors.New("Not yet implemented")
+}