Documentation ¶
Index ¶
Constants ¶
This section is empty.
Variables ¶
View Source
var ErrDataEncoding = errors.New("unknown data field encoding")
View Source
var ObjectCmd = &cmds.Command{ Helptext: cmds.HelpText{ Tagline: "Deprecated commands to interact with dag-pb objects. Use 'dag' or 'files' instead.", ShortDescription: ` 'ipfs object' is a legacy plumbing command used to manipulate dag-pb objects directly. Deprecated, use more modern 'ipfs dag' and 'ipfs files' instead.`, }, Subcommands: map[string]*cmds.Command{ "data": ObjectDataCmd, "diff": ObjectDiffCmd, "get": ObjectGetCmd, "links": ObjectLinksCmd, "new": ObjectNewCmd, "patch": ObjectPatchCmd, "put": ObjectPutCmd, "stat": ObjectStatCmd, }, }
View Source
var ObjectDataCmd = &cmds.Command{ Helptext: cmds.HelpText{ Tagline: "Deprecated way to read the raw bytes of a dag-pb object: use 'dag get' instead.", ShortDescription: ` 'ipfs object data' is a deprecated plumbing command for retrieving the raw bytes stored in a dag-pb node. It outputs to stdout, and <key> is a base58 encoded multihash. Provided for legacy reasons. Use 'ipfs dag get' instead. `, LongDescription: ` 'ipfs object data' is a deprecated plumbing command for retrieving the raw bytes stored in a dag-pb node. It outputs to stdout, and <key> is a base58 encoded multihash. Provided for legacy reasons. Use 'ipfs dag get' instead. 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.").EnableStdin(), }, Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error { api, err := cmdenv.GetApi(env, req) if err != nil { return err } path := path.New(req.Arguments[0]) data, err := api.Object().Data(req.Context, path) if err != nil { return err } return res.Emit(data) }, }
ObjectDataCmd object data command
View Source
var ObjectDiffCmd = &cmds.Command{ Helptext: cmds.HelpText{ Tagline: "Display the diff between two IPFS objects.", ShortDescription: ` 'ipfs object diff' is a command used to show the differences between two IPFS objects.`, LongDescription: ` 'ipfs object diff' is a command used to show the differences between two IPFS objects. Example: > ls foo bar baz/ giraffe > ipfs add -r foo ... Added QmegHcnrPgMwC7tBiMxChD54fgQMBUecNw9nE9UUU4x1bz foo > OBJ_A=QmegHcnrPgMwC7tBiMxChD54fgQMBUecNw9nE9UUU4x1bz > echo "different content" > foo/bar > ipfs add -r foo ... Added QmcmRptkSPWhptCttgHg27QNDmnV33wAJyUkCnAvqD3eCD foo > OBJ_B=QmcmRptkSPWhptCttgHg27QNDmnV33wAJyUkCnAvqD3eCD > ipfs object diff -v $OBJ_A $OBJ_B Changed "bar" from QmNgd5cz2jNftnAHBhcRUGdtiaMzb5Rhjqd4etondHHST8 to QmRfFVsjSXkhFxrfWnLpMae2M4GBVsry6VAuYYcji5MiZb. `, }, Arguments: []cmds.Argument{ cmds.StringArg("obj_a", true, false, "Object to diff against."), cmds.StringArg("obj_b", true, false, "Object to diff."), }, Options: []cmds.Option{ cmds.BoolOption(verboseOptionName, "v", "Print extra information."), }, Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error { api, err := cmdenv.GetApi(env, req) if err != nil { return err } pa := path.New(req.Arguments[0]) pb := path.New(req.Arguments[1]) changes, err := api.Object().Diff(req.Context, pa, pb) if err != nil { return err } out := make([]*dagutils.Change, len(changes)) for i, change := range changes { out[i] = &dagutils.Change{ Type: dagutils.ChangeType(change.Type), Path: change.Path, } if change.Before != nil { out[i].Before = change.Before.Cid() } if change.After != nil { out[i].After = change.After.Cid() } } return cmds.EmitOnce(res, &Changes{out}) }, Type: Changes{}, Encoders: cmds.EncoderMap{ cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, out *Changes) error { verbose, _ := req.Options[verboseOptionName].(bool) for _, change := range out.Changes { if verbose { switch change.Type { case dagutils.Add: fmt.Fprintf(w, "Added new link %q pointing to %s.\n", change.Path, change.After) case dagutils.Mod: fmt.Fprintf(w, "Changed %q from %s to %s.\n", change.Path, change.Before, change.After) case dagutils.Remove: fmt.Fprintf(w, "Removed link %q (was %s).\n", change.Path, change.Before) } } else { switch change.Type { case dagutils.Add: fmt.Fprintf(w, "+ %s %q\n", change.After, change.Path) case dagutils.Mod: fmt.Fprintf(w, "~ %s %s %q\n", change.Before, change.After, change.Path) case dagutils.Remove: fmt.Fprintf(w, "- %s %q\n", change.Before, change.Path) } } } return nil }), }, }
View Source
var ObjectGetCmd = &cmds.Command{ Helptext: cmds.HelpText{ Tagline: "Deprecated way to get and serialize the dag-pb node. Use 'dag get' instead", ShortDescription: ` 'ipfs object get' is a plumbing command for retrieving dag-pb nodes. It serializes the DAG node to the format specified by the "--encoding" flag. It outputs to stdout, and <key> is a base58 encoded multihash. DEPRECATED and provided for legacy reasons. Use 'ipfs dag get' instead. `, }, Arguments: []cmds.Argument{ cmds.StringArg("key", true, false, "Key of the dag-pb object to retrieve, in base58-encoded multihash format.").EnableStdin(), }, Options: []cmds.Option{ cmds.StringOption(encodingOptionName, "Encoding type of the data field, either \"text\" or \"base64\".").WithDefault("text"), }, Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error { api, err := cmdenv.GetApi(env, req) if err != nil { return err } enc, err := cmdenv.GetLowLevelCidEncoder(req) if err != nil { return err } path := path.New(req.Arguments[0]) datafieldenc, _ := req.Options[encodingOptionName].(string) if err != nil { return err } nd, err := api.Object().Get(req.Context, path) if err != nil { return err } r, err := api.Object().Data(req.Context, path) if err != nil { return err } data, err := ioutil.ReadAll(r) if err != nil { return err } out, err := encodeData(data, datafieldenc) if err != nil { return err } node := &Node{ Links: make([]Link, len(nd.Links())), Data: out, } for i, link := range nd.Links() { node.Links[i] = Link{ Hash: enc.Encode(link.Cid), Name: link.Name, Size: link.Size, } } return cmds.EmitOnce(res, node) }, Type: Node{}, Encoders: cmds.EncoderMap{ cmds.Protobuf: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, out *Node) error { object, err := deserializeNode(out, "text") if err != nil { return nil } marshaled, err := object.Marshal() if err != nil { return err } _, err = w.Write(marshaled) return err }), }, }
ObjectGetCmd object get command
View Source
var ObjectLinksCmd = &cmds.Command{ Helptext: cmds.HelpText{ Tagline: "Deprecated way to output links in the specified dag-pb object: use 'dag get' instead.", ShortDescription: ` 'ipfs object links' is a plumbing command for retrieving the links from a dag-pb node. It outputs to stdout, and <key> is a base58 encoded multihash. Provided for legacy reasons. Use 'ipfs dag get' instead. `, }, Arguments: []cmds.Argument{ cmds.StringArg("key", true, false, "Key of the dag-pb object to retrieve, in base58-encoded multihash format.").EnableStdin(), }, Options: []cmds.Option{ cmds.BoolOption(headersOptionName, "v", "Print table headers (Hash, Size, Name)."), }, Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error { api, err := cmdenv.GetApi(env, req) if err != nil { return err } enc, err := cmdenv.GetLowLevelCidEncoder(req) if err != nil { return err } path := path.New(req.Arguments[0]) rp, err := api.ResolvePath(req.Context, path) if err != nil { return err } links, err := api.Object().Links(req.Context, rp) if err != nil { return err } outLinks := make([]Link, len(links)) for i, link := range links { outLinks[i] = Link{ Hash: enc.Encode(link.Cid), Name: link.Name, Size: link.Size, } } out := &Object{ Hash: enc.Encode(rp.Cid()), Links: outLinks, } return cmds.EmitOnce(res, out) }, Encoders: cmds.EncoderMap{ cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, out *Object) error { tw := tabwriter.NewWriter(w, 1, 2, 1, ' ', 0) headers, _ := req.Options[headersOptionName].(bool) if headers { fmt.Fprintln(tw, "Hash\tSize\tName") } for _, link := range out.Links { fmt.Fprintf(tw, "%s\t%v\t%s\n", link.Hash, link.Size, cmdenv.EscNonPrint(link.Name)) } tw.Flush() return nil }), }, Type: &Object{}, }
ObjectLinksCmd object links command
View Source
var ObjectNewCmd = &cmds.Command{ Helptext: cmds.HelpText{ Tagline: "Deprecated way to create a new dag-pb object from a template.", ShortDescription: ` 'ipfs object new' is a plumbing command for creating new dag-pb nodes. DEPRECATED and provided for legacy reasons. Use 'dag put' and 'files' instead. `, LongDescription: ` 'ipfs object new' is a plumbing command for creating new dag-pb 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. Available templates: * unixfs-dir DEPRECATED and provided for legacy reasons. Use 'dag put' and 'files' instead. `, }, Arguments: []cmds.Argument{ cmds.StringArg("template", false, false, "Template to use. Optional."), }, Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error { api, err := cmdenv.GetApi(env, req) if err != nil { return err } enc, err := cmdenv.GetLowLevelCidEncoder(req) if err != nil { return err } template := "empty" if len(req.Arguments) == 1 { template = req.Arguments[0] } nd, err := api.Object().New(req.Context, options.Object.Type(template)) if err != nil && err != io.EOF { return err } return cmds.EmitOnce(res, &Object{Hash: enc.Encode(nd.Cid())}) }, Encoders: cmds.EncoderMap{ cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, out *Object) error { fmt.Fprintln(w, out.Hash) return nil }), }, Type: Object{}, }
ObjectNewCmd object new command
View Source
var ObjectPatchCmd = &cmds.Command{ Helptext: cmds.HelpText{ Tagline: "Deprecated way to create a new merkledag object based on an existing one. Use MFS with 'files cp|rm' instead.", ShortDescription: ` 'ipfs object patch <root> <cmd> <args>' is a plumbing command used to build custom dag-pb objects. It mutates objects, creating new objects as a result. This is the Merkle-DAG version of modifying an object. DEPRECATED and provided for legacy reasons. For modern use cases, use MFS with 'files' commands: 'ipfs files --help'. $ ipfs files cp /ipfs/QmUNLLsPACCz1vLxQVkXqqLX5R1X345qqfHbsf67hvA3Nn /some-dir $ ipfs files cp /ipfs/Qmayz4F4UzqcAMitTzU4zCSckDofvxstDuj3y7ajsLLEVs /some-dir/added-file.jpg $ ipfs files stat --hash /some-dir The above will add 'added-file.jpg' to the directory placed under /some-dir and the CID of updated directory is returned by 'files stat' 'files cp' does not download the data, only the root block, which makes it possible to build arbitrary directory trees without fetching them in full to the local node. `, }, Arguments: []cmds.Argument{}, Subcommands: map[string]*cmds.Command{ "append-data": patchAppendDataCmd, "add-link": patchAddLinkCmd, "rm-link": patchRmLinkCmd, "set-data": patchSetDataCmd, }, }
View Source
var ObjectPutCmd = &cmds.Command{ Helptext: cmds.HelpText{ Tagline: "Deprecated way to store input as a DAG object. Use 'dag put' instead.", ShortDescription: ` 'ipfs object put' is a plumbing command for storing dag-pb nodes. It reads from stdin, and the output is a base58 encoded multihash. DEPRECATED and provided for legacy reasons. Use 'ipfs dag put' instead. `, }, Arguments: []cmds.Argument{ cmds.FileArg("data", true, false, "Data to be stored as a dag-pb object.").EnableStdin(), }, Options: []cmds.Option{ cmds.StringOption(inputencOptionName, "Encoding type of input data. One of: {\"protobuf\", \"json\"}.").WithDefault("json"), cmds.StringOption(datafieldencOptionName, "Encoding type of the data field, either \"text\" or \"base64\".").WithDefault("text"), cmds.BoolOption(pinOptionName, "Pin this object when adding."), cmds.BoolOption(quietOptionName, "q", "Write minimal output."), }, Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error { api, err := cmdenv.GetApi(env, req) if err != nil { return err } enc, err := cmdenv.GetLowLevelCidEncoder(req) if err != nil { return err } file, err := cmdenv.GetFileArg(req.Files.Entries()) if err != nil { return err } inputenc, _ := req.Options[inputencOptionName].(string) if err != nil { return err } datafieldenc, _ := req.Options[datafieldencOptionName].(string) if err != nil { return err } dopin, _ := req.Options[pinOptionName].(bool) if err != nil { return err } p, err := api.Object().Put(req.Context, file, options.Object.DataType(datafieldenc), options.Object.InputEnc(inputenc), options.Object.Pin(dopin)) if err != nil { return err } return cmds.EmitOnce(res, &Object{Hash: enc.Encode(p.Cid())}) }, Encoders: cmds.EncoderMap{ cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, out *Object) error { quiet, _ := req.Options[quietOptionName].(bool) o := out.Hash if !quiet { o = "added " + o } fmt.Fprintln(w, o) return nil }), }, Type: Object{}, }
ObjectPutCmd object put command
View Source
var ObjectStatCmd = &cmds.Command{ Helptext: cmds.HelpText{ Tagline: "Deprecated way to read stats for the dag-pb node. Use 'files stat' instead.", ShortDescription: ` 'ipfs object stat' is a plumbing command to print dag-pb node statistics. <key> is a base58 encoded multihash. DEPRECATED: modern replacements are 'files stat' and 'dag stat' `, LongDescription: ` 'ipfs object stat' is a plumbing command to print dag-pb node statistics. <key> is a base58 encoded multihash. It outputs to stdout: NumLinks int number of links in link table BlockSize int size of the raw, encoded data LinksSize int size of the links segment DataSize int size of the data segment CumulativeSize int cumulative size of object and its references DEPRECATED: Provided for legacy reasons. Modern replacements: For unixfs, 'ipfs files stat' can be used: $ ipfs files stat --with-local /ipfs/QmWfVY9y3xjsixTgbd9AorQxH7VtMpzfx2HaWtsoUYecaX QmWfVY9y3xjsixTgbd9AorQxH7VtMpzfx2HaWtsoUYecaX Size: 5 CumulativeSize: 13 ChildBlocks: 0 Type: file Local: 13 B of 13 B (100.00%) Reported sizes are based on metadata present in root block, and should not be trusted. A slower, but more secure alternative is 'ipfs dag stat', which will work for every DAG type. It comes with a benefit of calculating the size by walking the DAG: $ ipfs dag stat /ipfs/QmWfVY9y3xjsixTgbd9AorQxH7VtMpzfx2HaWtsoUYecaX Size: 13, NumBlocks: 1 `, }, Arguments: []cmds.Argument{ cmds.StringArg("key", true, false, "Key of the object to retrieve, in base58-encoded multihash format.").EnableStdin(), }, Options: []cmds.Option{ cmds.BoolOption(humanOptionName, "Print sizes in human readable format (e.g., 1K 234M 2G)"), }, Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error { api, err := cmdenv.GetApi(env, req) if err != nil { return err } enc, err := cmdenv.GetLowLevelCidEncoder(req) if err != nil { return err } ns, err := api.Object().Stat(req.Context, path.New(req.Arguments[0])) if err != nil { return err } oldStat := &ipld.NodeStat{ Hash: enc.Encode(ns.Cid), NumLinks: ns.NumLinks, BlockSize: ns.BlockSize, LinksSize: ns.LinksSize, DataSize: ns.DataSize, CumulativeSize: ns.CumulativeSize, } return cmds.EmitOnce(res, oldStat) }, Type: ipld.NodeStat{}, Encoders: cmds.EncoderMap{ cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, out *ipld.NodeStat) error { wtr := tabwriter.NewWriter(w, 0, 0, 1, ' ', 0) defer wtr.Flush() fw := func(s string, n int) { fmt.Fprintf(wtr, "%s:\t%d\n", s, n) } human, _ := req.Options[humanOptionName].(bool) fw("NumLinks", out.NumLinks) fw("BlockSize", out.BlockSize) fw("LinksSize", out.LinksSize) fw("DataSize", out.DataSize) if human { fmt.Fprintf(wtr, "%s:\t%s\n", "CumulativeSize", humanize.Bytes(uint64(out.CumulativeSize))) } else { fw("CumulativeSize", out.CumulativeSize) } return nil }), }, }
ObjectStatCmd object stat command
Functions ¶
This section is empty.
Types ¶
Click to show internal directories.
Click to hide internal directories.