Objects []Object
}
var lsCmd = &cmds.Command{
Helptext: cmds.HelpText{
Tagline: "List links from an object.",
ShortDescription: `
Retrieves the object named by <ipfs-path> and displays the links
it contains, with the following format:
<link base58 hash> <link size in bytes> <link name>
`,
},
Arguments: []cmds.Argument{
cmds.StringArg("ipfs-path", true, true, "The path to the IPFS object(s) to list links from"),
},
Run: func(req cmds.Request) (interface{}, error) {
node, err := req.Context().GetNode()
if err != nil {
return nil, err
}
paths := req.Arguments()
dagnodes := make([]*merkledag.Node, 0)
for _, path := range paths {
dagnode, err := node.Resolver.ResolvePath(path)
if err != nil {
return nil, err
}
"get": blockGetCmd,
"put": blockPutCmd,
},
}
var blockGetCmd = &cmds.Command{
Helptext: cmds.HelpText{
Tagline: "Get a raw IPFS block",
ShortDescription: `
'ipfs block get' is a plumbing command for retreiving raw ipfs blocks.
It outputs to stdout, and <key> is a base58 encoded multihash.
`,
},
Arguments: []cmds.Argument{
cmds.StringArg("key", true, false, "The base58 multihash of an existing block to get"),
},
Run: func(req cmds.Request) (interface{}, error) {
n, err := req.Context().GetNode()
if err != nil {
return nil, err
}
key := req.Arguments()[0]
if !u.IsValidHash(key) {
return nil, cmds.Error{"Not a valid hash", cmds.ErrClient}
}
h, err := mh.FromB58String(key)
if err != nil {
PublicKey string
Addresses []string
AgentVersion string
ProtocolVersion string
}
var idCmd = &cmds.Command{
Helptext: cmds.HelpText{
Tagline: "Show IPFS Node ID info",
ShortDescription: `
Prints out information about the specified peer,
if no peer is specified, prints out local peers info.
`,
},
Arguments: []cmds.Argument{
cmds.StringArg("peerid", false, false, "peer.ID of node to look up"),
},
Run: func(req cmds.Request) (interface{}, error) {
node, err := req.Context().GetNode()
if err != nil {
return nil, err
}
if len(req.Arguments()) == 0 {
return printPeer(node.Identity)
}
pid := req.Arguments()[0]
id := peer.ID(b58.Decode(pid))
if len(id) == 0 {
cmds "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/commands"
core "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/core"
uio "github.com/maybebtc/interplanetary/Godeps/_workspace/src/github.com/jbenet/go-ipfs/unixfs/io"
)
var CatCmd = &cmds.Command{
Helptext: cmds.HelpText{
Tagline: "Show IPFS object data",
ShortDescription: `
Retrieves the object named by <ipfs-path> and outputs the data
it contains.
`,
},
Arguments: []cmds.Argument{
cmds.StringArg("ipfs-path", true, true, "The path to the IPFS object(s) to be outputted"),
},
Run: func(req cmds.Request) (interface{}, error) {
node, err := req.Context().GetNode()
if err != nil {
return nil, err
}
readers := make([]io.Reader, 0, len(req.Arguments()))
readers, err = cat(node, req.Arguments())
if err != nil {
return nil, err
}
reader := io.MultiReader(readers...)
},
Type: &stringList{},
}
var swarmConnectCmd = &cmds.Command{
Helptext: cmds.HelpText{
Tagline: "Open connection to a given peer",
ShortDescription: `
'ipfs swarm connect' opens a connection to a peer address. The address format
is an ipfs multiaddr:
ipfs swarm connect /ip4/104.131.131.82/tcp/4001/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ
`,
},
Arguments: []cmds.Argument{
cmds.StringArg("address", true, true, "address of peer to connect to"),
},
Run: func(req cmds.Request) (interface{}, error) {
ctx := context.TODO()
log.Debug("ipfs swarm connect")
n, err := req.Context().GetNode()
if err != nil {
return nil, err
}
addrs := req.Arguments()
if n.Network == nil {
return nil, errNotOnline
}
// we convert it at this step.
var logAllKeyword = "all"
var LogCmd = &cmds.Command{
Helptext: cmds.HelpText{
Tagline: "Change the logging level",
ShortDescription: `
'ipfs log' is a utility command used to change the logging
output of a running daemon.
`,
},
Arguments: []cmds.Argument{
// TODO use a different keyword for 'all' because all can theoretically
// clash with a subsystem name
cmds.StringArg("subsystem", true, false, fmt.Sprintf("the subsystem logging identifier. Use '%s' for all subsystems.", logAllKeyword)),
cmds.StringArg("level", true, false, "one of: debug, info, notice, warning, error, critical"),
},
Run: func(req cmds.Request) (interface{}, error) {
args := req.Arguments()
subsystem, level := args[0], args[1]
if subsystem == logAllKeyword {
subsystem = "*"
}
if err := u.SetLogLevel(subsystem, level); err != nil {
return nil, err
}
ipfs data is a plumbing command for retreiving the raw bytes stored in
a DAG node. It outputs to stdout, and <key> is a base58 encoded
multihash.
`,
LongDescription: `
ipfs data is a plumbing command for retreiving the raw bytes stored in
a DAG node. It outputs to stdout, and <key> is a base58 encoded
multihash.
Note that the "--encoding" option does not affect the output, since the
output is the raw data of the object.
`,
},
Arguments: []cmds.Argument{
cmds.StringArg("key", true, false, "Key of the object to retrieve, in base58-encoded multihash format"),
},
Run: func(req cmds.Request) (interface{}, error) {
n, err := req.Context().GetNode()
if err != nil {
return nil, err
}
key := req.Arguments()[0]
return objectData(n, key)
},
}
var objectLinksCmd = &cmds.Command{
Helptext: cmds.HelpText{
Tagline: "Outputs the links pointed to by the specified object",
var refsCmd = &cmds.Command{
Helptext: cmds.HelpText{
Tagline: "Lists link hashes from an object",
ShortDescription: `
Retrieves the object named by <ipfs-path> and displays the link
hashes it contains, with the following format:
<link base58 hash>
Note: list all refs recursively with -r.
`,
},
Arguments: []cmds.Argument{
cmds.StringArg("ipfs-path", true, true, "Path to the object(s) to list refs from"),
},
Options: []cmds.Option{
cmds.BoolOption("unique", "u", "Omit duplicate refs from output"),
cmds.BoolOption("recursive", "r", "Recursively list links of child nodes"),
},
Run: func(req cmds.Request) (interface{}, error) {
n, err := req.Context().GetNode()
if err != nil {
return nil, err
}
unique, found, err := req.Option("unique").Bool()
if err != nil {
return nil, err
}
"list": bootstrapListCmd,
"add": bootstrapAddCmd,
"rm": bootstrapRemoveCmd,
},
}
var bootstrapAddCmd = &cmds.Command{
Helptext: cmds.HelpText{
Tagline: "Add peers to the bootstrap list",
ShortDescription: `Outputs a list of peers that were added (that weren't already
in the bootstrap list).
` + bootstrapSecurityWarning,
},
Arguments: []cmds.Argument{
cmds.StringArg("peer", true, true, peerOptionDesc),
},
Run: func(req cmds.Request) (interface{}, error) {
input, err := bootstrapInputToPeers(req.Arguments())
if err != nil {
return nil, err
}
filename, err := config.Filename(req.Context().ConfigRoot)
if err != nil {
return nil, err
}
cfg, err := req.Context().GetConfig()
if err != nil {
return nil, err
Examples:
Publish a <ref> to your identity name:
> ipfs name publish QmatmE9msSfkKxoffpHwNLNKgwZG8eT9Bud6YoPab52vpy
published name QmbCMUZw6JFeZ7Wp9jkzbye3Fzp2GGcPgC3nmeUjfVF87n to QmatmE9msSfkKxoffpHwNLNKgwZG8eT9Bud6YoPab52vpy
Publish a <ref> to another public key:
> ipfs name publish QmbCMUZw6JFeZ7Wp9jkzbye3Fzp2GGcPgC3nmeUjfVF87n QmatmE9msSfkKxoffpHwNLNKgwZG8eT9Bud6YoPab52vpy
published name QmbCMUZw6JFeZ7Wp9jkzbye3Fzp2GGcPgC3nmeUjfVF87n to QmatmE9msSfkKxoffpHwNLNKgwZG8eT9Bud6YoPab52vpy
`,
},
Arguments: []cmds.Argument{
cmds.StringArg("name", false, false, "The IPNS name to publish to. Defaults to your node's peerID"),
cmds.StringArg("ipfs-path", true, false, "IPFS path of the obejct to be published at <name>"),
},
Run: func(req cmds.Request) (interface{}, error) {
log.Debug("Begin Publish")
n, err := req.Context().GetNode()
if err != nil {
return nil, err
}
args := req.Arguments()
if n.Network == nil {
return nil, errNotOnline
}
func TestArgumentParsing(t *testing.T) {
rootCmd := &commands.Command{
Subcommands: map[string]*commands.Command{
"noarg": &commands.Command{},
"onearg": &commands.Command{
Arguments: []commands.Argument{
commands.StringArg("a", true, false, "some arg"),
},
},
"twoargs": &commands.Command{
Arguments: []commands.Argument{
commands.StringArg("a", true, false, "some arg"),
commands.StringArg("b", true, false, "another arg"),
},
},
"variadic": &commands.Command{
Arguments: []commands.Argument{
commands.StringArg("a", true, true, "some arg"),
},
},
"optional": &commands.Command{
Arguments: []commands.Argument{
commands.StringArg("b", false, true, "another arg"),
},
},
"reversedoptional": &commands.Command{
Arguments: []commands.Argument{
commands.StringArg("a", false, false, "some arg"),
commands.StringArg("b", true, false, "another arg"),
},
},
},
}
_, _, _, err := Parse([]string{"noarg"}, nil, rootCmd)
if err != nil {
t.Error("Should have passed")
}
_, _, _, err = Parse([]string{"noarg", "value!"}, nil, rootCmd)
if err == nil {
t.Error("Should have failed (provided an arg, but command didn't define any)")
}
_, _, _, err = Parse([]string{"onearg", "value!"}, nil, rootCmd)
if err != nil {
t.Error("Should have passed")
}
_, _, _, err = Parse([]string{"onearg"}, nil, rootCmd)
if err == nil {
t.Error("Should have failed (didn't provide any args, arg is required)")
}
_, _, _, err = Parse([]string{"twoargs", "value1", "value2"}, nil, rootCmd)
if err != nil {
t.Error("Should have passed")
}
_, _, _, err = Parse([]string{"twoargs", "value!"}, nil, rootCmd)
if err == nil {
t.Error("Should have failed (only provided 1 arg, needs 2)")
}
_, _, _, err = Parse([]string{"twoargs"}, nil, rootCmd)
if err == nil {
t.Error("Should have failed (didn't provide any args, 2 required)")
}
_, _, _, err = Parse([]string{"variadic", "value!"}, nil, rootCmd)
if err != nil {
t.Error("Should have passed")
}
_, _, _, err = Parse([]string{"variadic", "value1", "value2", "value3"}, nil, rootCmd)
if err != nil {
t.Error("Should have passed")
}
_, _, _, err = Parse([]string{"variadic"}, nil, rootCmd)
if err == nil {
t.Error("Should have failed (didn't provide any args, 1 required)")
}
_, _, _, err = Parse([]string{"optional", "value!"}, nil, rootCmd)
if err != nil {
t.Error("Should have passed")
}
_, _, _, err = Parse([]string{"optional"}, nil, rootCmd)
if err != nil {
t.Error("Should have passed")
}
_, _, _, err = Parse([]string{"reversedoptional", "value1", "value2"}, nil, rootCmd)
if err != nil {
t.Error("Should have passed")
}
_, _, _, err = Parse([]string{"reversedoptional", "value!"}, nil, rootCmd)
if err != nil {
t.Error("Should have passed")
}
_, _, _, err = Parse([]string{"reversedoptional"}, nil, rootCmd)
if err == nil {
t.Error("Should have failed (didn't provide any args, 1 required)")
}
_, _, _, err = Parse([]string{"reversedoptional", "value1", "value2", "value3"}, nil, rootCmd)
if err == nil {
t.Error("Should have failed (provided too many args, only takes 1)")
}
}
file inside your IPFS repository.
EXAMPLES:
Get the value of the 'datastore.path' key:
ipfs config datastore.path
Set the value of the 'datastore.path' key:
ipfs config datastore.path ~/.go-ipfs/datastore
`,
},
Arguments: []cmds.Argument{
cmds.StringArg("key", true, false, "The key of the config entry (e.g. \"Addresses.API\")"),
cmds.StringArg("value", false, false, "The value to set the config entry to"),
},
Run: func(req cmds.Request) (interface{}, error) {
args := req.Arguments()
key := args[0]
filename, err := config.Filename(req.Context().ConfigRoot)
if err != nil {
return nil, err
}
var value string
if len(args) == 2 {
value = args[1]
return setConfig(filename, key, value)
Resolve the value of your identity:
> ipfs name resolve
QmatmE9msSfkKxoffpHwNLNKgwZG8eT9Bud6YoPab52vpy
Resolve te value of another name:
> ipfs name resolve QmbCMUZw6JFeZ7Wp9jkzbye3Fzp2GGcPgC3nmeUjfVF87n
QmatmE9msSfkKxoffpHwNLNKgwZG8eT9Bud6YoPab52vpy
`,
},
Arguments: []cmds.Argument{
cmds.StringArg("name", false, false, "The IPNS name to resolve. Defaults to your node's peerID."),
},
Run: func(req cmds.Request) (interface{}, error) {
n, err := req.Context().GetNode()
if err != nil {
return nil, err
}
var name string
if n.Network == nil {
return nil, errNotOnline
}
if len(req.Arguments()) == 0 {
"rm": rmPinCmd,
"ls": listPinCmd,
},
}
var addPinCmd = &cmds.Command{
Helptext: cmds.HelpText{
Tagline: "Pins objects to local storage",
ShortDescription: `
Retrieves the object named by <ipfs-path> and stores it locally
on disk.
`,
},
Arguments: []cmds.Argument{
cmds.StringArg("ipfs-path", true, true, "Path to object(s) to be pinned"),
},
Options: []cmds.Option{
cmds.BoolOption("recursive", "r", "Recursively pin the object linked to by the specified object(s)"),
},
Run: func(req cmds.Request) (interface{}, error) {
n, err := req.Context().GetNode()
if err != nil {
return nil, err
}
// set recursive flag
recursive, found, err := req.Option("recursive").Bool()
if err != nil {
return nil, err
}