go-ipfs: github.com/ipfs/go-ipfs/core/commands/dag Index | Files

package dagcmd

import "github.com/ipfs/go-ipfs/core/commands/dag"

Index

Package Files

dag.go

Variables

var DagCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "Interact with ipld dag objects.",
        ShortDescription: "" /* 217 byte string literal not displayed */,
    },
    Subcommands: map[string]*cmds.Command{
        "put":     DagPutCmd,
        "get":     DagGetCmd,
        "resolve": DagResolveCmd,
    },
}
var DagGetCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline: "Get a dag node from ipfs.",
        ShortDescription: `
'ipfs dag get' fetches a dag node from ipfs and prints it out in the specified
format.
`,
    },
    Arguments: []cmds.Argument{
        cmds.StringArg("ref", true, false, "The object to get").EnableStdin(),
    },
    Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
        api, err := cmdenv.GetApi(env, req)
        if err != nil {
            return err
        }

        rp, err := api.ResolvePath(req.Context, path.New(req.Arguments[0]))
        if err != nil {
            return err
        }

        obj, err := api.Dag().Get(req.Context, rp.Cid())
        if err != nil {
            return err
        }

        var out interface{} = obj
        if len(rp.Remainder()) > 0 {
            rem := strings.Split(rp.Remainder(), "/")
            final, _, err := obj.Resolve(rem)
            if err != nil {
                return err
            }
            out = final
        }
        return cmds.EmitOnce(res, &out)
    },
}
var DagPutCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline: "Add a dag node to ipfs.",
        ShortDescription: `
'ipfs dag put' accepts input from a file or stdin and parses it
into an object of the specified format.
`,
    },
    Arguments: []cmds.Argument{
        cmds.FileArg("object data", true, true, "The object to put").EnableStdin(),
    },
    Options: []cmds.Option{
        cmds.StringOption("format", "f", "Format that the object will be added as.").WithDefault("cbor"),
        cmds.StringOption("input-enc", "Format that the input object will be.").WithDefault("json"),
        cmds.BoolOption("pin", "Pin this object when adding."),
        cmds.StringOption("hash", "Hash function to use").WithDefault(""),
    },
    Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
        api, err := cmdenv.GetApi(env, req)
        if err != nil {
            return err
        }

        ienc, _ := req.Options["input-enc"].(string)
        format, _ := req.Options["format"].(string)
        hash, _ := req.Options["hash"].(string)
        dopin, _ := req.Options["pin"].(bool)

        mhType := uint64(math.MaxUint64)

        if hash != "" {
            var ok bool
            mhType, ok = mh.Names[hash]
            if !ok {
                return fmt.Errorf("%s in not a valid multihash name", hash)
            }
        }

        var adder ipld.NodeAdder = api.Dag()
        if dopin {
            adder = api.Dag().Pinning()
        }
        b := ipld.NewBatch(req.Context, adder)

        it := req.Files.Entries()
        for it.Next() {
            file := files.FileFromEntry(it)
            if file == nil {
                return fmt.Errorf("expected a regular file")
            }
            nds, err := coredag.ParseInputs(ienc, format, file, mhType, -1)
            if err != nil {
                return err
            }
            if len(nds) == 0 {
                return fmt.Errorf("no node returned from ParseInputs")
            }

            for _, nd := range nds {
                err := b.Add(req.Context, nd)
                if err != nil {
                    return err
                }
            }

            cid := nds[0].Cid()
            if err := res.Emit(&OutputObject{Cid: cid}); err != nil {
                return err
            }
        }
        if it.Err() != nil {
            return it.Err()
        }

        if err := b.Commit(); err != nil {
            return err
        }

        return nil
    },
    Type: OutputObject{},
    Encoders: cmds.EncoderMap{
        cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, out *OutputObject) error {
            enc, err := cmdenv.GetLowLevelCidEncoder(req)
            if err != nil {
                return err
            }
            fmt.Fprintln(w, enc.Encode(out.Cid))
            return nil
        }),
    },
}
var DagResolveCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline: "Resolve ipld block",
        ShortDescription: `
'ipfs dag resolve' fetches a dag node from ipfs, prints it's address and remaining path.
`,
    },
    Arguments: []cmds.Argument{
        cmds.StringArg("ref", true, false, "The path to resolve").EnableStdin(),
    },
    Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
        api, err := cmdenv.GetApi(env, req)
        if err != nil {
            return err
        }

        rp, err := api.ResolvePath(req.Context, path.New(req.Arguments[0]))
        if err != nil {
            return err
        }

        return cmds.EmitOnce(res, &ResolveOutput{
            Cid:     rp.Cid(),
            RemPath: rp.Remainder(),
        })
    },
    Encoders: cmds.EncoderMap{
        cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, out *ResolveOutput) error {
            var (
                enc cidenc.Encoder
                err error
            )
            switch {
            case !cmdenv.CidBaseDefined(req):

                enc, err = cmdenv.CidEncoderFromPath(req.Arguments[0])
                if err == nil {
                    break
                }

                fallthrough
            default:
                enc, err = cmdenv.GetLowLevelCidEncoder(req)
                if err != nil {
                    return err
                }
            }
            p := enc.Encode(out.Cid)
            if out.RemPath != "" {
                p = ipfspath.Join([]string{p, out.RemPath})
            }

            fmt.Fprint(w, p)
            return nil
        }),
    },
    Type: ResolveOutput{},
}

DagResolveCmd returns address of highest block within a path and a path remainder

type OutputObject Uses

type OutputObject struct {
    Cid cid.Cid
}

OutputObject is the output type of 'dag put' command

type ResolveOutput Uses

type ResolveOutput struct {
    Cid     cid.Cid
    RemPath string
}

ResolveOutput is the output type of 'dag resolve' command

Package dagcmd imports 14 packages (graph) and is imported by 11 packages. Updated 2019-05-18. Refresh now. Tools for package owners.