import "github.com/ipfs/go-ipfs/core/commands/object"
var ObjectCmd = &cmds.Command{ Helptext: cmds.HelpText{ Tagline: "Interact with IPFS objects.", ShortDescription: ` 'ipfs object' is a plumbing command used to manipulate DAG objects directly.`, }, Subcommands: map[string]*cmds.Command{ "data": ObjectDataCmd, "diff": ObjectDiffCmd, "get": ObjectGetCmd, "links": ObjectLinksCmd, "new": ObjectNewCmd, "patch": ObjectPatchCmd, "put": ObjectPutCmd, "stat": ObjectStatCmd, }, }
var ObjectDataCmd = &cmds.Command{ Helptext: cmds.HelpText{ Tagline: "Output the raw bytes of an IPFS object.", ShortDescription: "" /* 158 byte string literal not displayed */, LongDescription: "" /* 269 byte string literal not displayed */, }, 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
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: "" /* 624 byte string literal not displayed */, }, 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 }), }, }
var ObjectGetCmd = &cmds.Command{ Helptext: cmds.HelpText{ Tagline: "Get and serialize the DAG node named by <key>.", ShortDescription: "" /* 209 byte string literal not displayed */, LongDescription: "" /* 494 byte string literal not displayed */, }, Arguments: []cmds.Argument{ cmds.StringArg("key", true, false, "Key of the 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
var ObjectLinksCmd = &cmds.Command{ Helptext: cmds.HelpText{ Tagline: "Output the links pointed to by the specified object.", ShortDescription: "" /* 150 byte string literal not displayed */, }, 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(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, link.Name) } tw.Flush() return nil }), }, Type: &Object{}, }
ObjectLinksCmd object links command
var ObjectNewCmd = &cmds.Command{ Helptext: cmds.HelpText{ Tagline: "Create a new object from an ipfs template.", ShortDescription: ` 'ipfs object new' is a plumbing command for creating new DAG nodes. `, LongDescription: "" /* 247 byte string literal not displayed */, }, 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
var ObjectPatchCmd = &cmds.Command{ Helptext: cmds.HelpText{ Tagline: "Create a new merkledag object based on an existing one.", ShortDescription: "" /* 208 byte string literal not displayed */, }, Arguments: []cmds.Argument{}, Subcommands: map[string]*cmds.Command{ "append-data": patchAppendDataCmd, "add-link": patchAddLinkCmd, "rm-link": patchRmLinkCmd, "set-data": patchSetDataCmd, }, }
var ObjectPutCmd = &cmds.Command{ Helptext: cmds.HelpText{ Tagline: "Store input as a DAG object, print its key.", ShortDescription: "" /* 133 byte string literal not displayed */, LongDescription: "" /* 704 byte string literal not displayed */, }, Arguments: []cmds.Argument{ cmds.FileArg("data", true, false, "Data to be stored as a DAG 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
var ObjectStatCmd = &cmds.Command{ Helptext: cmds.HelpText{ Tagline: "Get stats for the DAG node named by <key>.", ShortDescription: "" /* 395 byte string literal not displayed */, }, 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
Package objectcmd imports 15 packages (graph) and is imported by 33 packages. Updated 2019-12-07. Refresh now. Tools for package owners.