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

package commands

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

Package commands implements the ipfs command interface

Using github.com/ipfs/go-ipfs/commands to define the command line and HTTP APIs. This is the interface available to folks using IPFS from outside of the Go language.

Index

Package Files

active.go add.go bitswap.go block.go bootstrap.go cat.go cid.go commands.go config.go dht.go diag.go dns.go external.go files.go filestore.go get.go id.go keystore.go log.go ls.go mount_unix.go p2p.go pin.go ping.go pubsub.go refs.go repo.go resolve.go root.go shutdown.go stat.go swarm.go sysdiag.go tar.go urlstore.go version.go

Constants

const (
    ConfigOption  = "config"
    DebugOption   = "debug"
    LocalOption   = "local" // DEPRECATED: use OfflineOption
    OfflineOption = "offline"
    ApiOption     = "api"
)
const P2PProtoPrefix = "/x/"

P2PProtoPrefix is the default required prefix for protocol names

Variables

var ActiveReqsCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline: "List commands run on this IPFS node.",
        ShortDescription: `
Lists running and recently run commands.
`,
    },
    Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
        ctx := env.(*oldcmds.Context)
        return cmds.EmitOnce(res, ctx.ReqLog.Report())
    },
    Options: []cmds.Option{
        cmds.BoolOption(verboseOptionName, "v", "Print extra information."),
    },
    Subcommands: map[string]*cmds.Command{
        "clear":    clearInactiveCmd,
        "set-time": setRequestClearCmd,
    },
    Encoders: cmds.EncoderMap{
        cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, out *[]*cmds.ReqLogEntry) error {
            verbose, _ := req.Options[verboseOptionName].(bool)

            tw := tabwriter.NewWriter(w, 4, 4, 2, ' ', 0)
            if verbose {
                fmt.Fprint(tw, "ID\t")
            }
            fmt.Fprint(tw, "Command\t")
            if verbose {
                fmt.Fprint(tw, "Arguments\tOptions\t")
            }
            fmt.Fprintln(tw, "Active\tStartTime\tRunTime")

            for _, req := range *out {
                if verbose {
                    fmt.Fprintf(tw, "%d\t", req.ID)
                }
                fmt.Fprintf(tw, "%s\t", req.Command)
                if verbose {
                    fmt.Fprintf(tw, "%v\t[", req.Args)
                    var keys []string
                    for k := range req.Options {
                        keys = append(keys, k)
                    }
                    sort.Strings(keys)

                    for _, k := range keys {
                        fmt.Fprintf(tw, "%s=%v,", k, req.Options[k])
                    }
                    fmt.Fprintf(tw, "]\t")
                }

                var live time.Duration
                if req.Active {
                    live = time.Since(req.StartTime)
                } else {
                    live = req.EndTime.Sub(req.StartTime)
                }
                t := req.StartTime.Format(time.Stamp)
                fmt.Fprintf(tw, "%t\t%s\t%s\n", req.Active, t, live)
            }
            tw.Flush()

            return nil
        }),
    },
    Type: []*cmds.ReqLogEntry{},
}
var AddCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline: "Add a file or directory to ipfs.",
        ShortDescription: `
Adds contents of <path> to ipfs. Use -r to add directories (recursively).
`,
        LongDescription: "" /* 2170 byte string literal not displayed */,
    },

    Arguments: []cmds.Argument{
        cmds.FileArg("path", true, true, "The path to a file to be added to ipfs.").EnableRecursive().EnableStdin(),
    },
    Options: []cmds.Option{
        cmds.OptionRecursivePath,
        cmds.OptionDerefArgs,
        cmds.OptionStdinName,
        cmds.OptionHidden,
        cmds.BoolOption(quietOptionName, "q", "Write minimal output."),
        cmds.BoolOption(quieterOptionName, "Q", "Write only final hash."),
        cmds.BoolOption(silentOptionName, "Write no output."),
        cmds.BoolOption(progressOptionName, "p", "Stream progress data."),
        cmds.BoolOption(trickleOptionName, "t", "Use trickle-dag format for dag generation."),
        cmds.BoolOption(onlyHashOptionName, "n", "Only chunk and hash - do not write to disk."),
        cmds.BoolOption(wrapOptionName, "w", "Wrap files with a directory object."),
        cmds.StringOption(chunkerOptionName, "s", "Chunking algorithm, size-[bytes], rabin-[min]-[avg]-[max] or buzhash").WithDefault("size-262144"),
        cmds.BoolOption(pinOptionName, "Pin this object when adding.").WithDefault(true),
        cmds.BoolOption(rawLeavesOptionName, "Use raw blocks for leaf nodes. (experimental)"),
        cmds.BoolOption(noCopyOptionName, "Add the file using filestore. Implies raw-leaves. (experimental)"),
        cmds.BoolOption(fstoreCacheOptionName, "Check the filestore for pre-existing blocks. (experimental)"),
        cmds.IntOption(cidVersionOptionName, "CID version. Defaults to 0 unless an option that depends on CIDv1 is passed. (experimental)"),
        cmds.StringOption(hashOptionName, "Hash function to use. Implies CIDv1 if not sha2-256. (experimental)").WithDefault("sha2-256"),
        cmds.BoolOption(inlineOptionName, "Inline small blocks into CIDs. (experimental)"),
        cmds.IntOption(inlineLimitOptionName, "Maximum block size to inline. (experimental)").WithDefault(32),
    },
    PreRun: func(req *cmds.Request, env cmds.Environment) error {
        quiet, _ := req.Options[quietOptionName].(bool)
        quieter, _ := req.Options[quieterOptionName].(bool)
        quiet = quiet || quieter

        silent, _ := req.Options[silentOptionName].(bool)

        if quiet || silent {
            return nil
        }

        _, found := req.Options[progressOptionName].(bool)
        if !found {
            req.Options[progressOptionName] = true
        }

        return nil
    },
    Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
        api, err := cmdenv.GetApi(env, req)
        if err != nil {
            return err
        }

        progress, _ := req.Options[progressOptionName].(bool)
        trickle, _ := req.Options[trickleOptionName].(bool)
        wrap, _ := req.Options[wrapOptionName].(bool)
        hash, _ := req.Options[onlyHashOptionName].(bool)
        silent, _ := req.Options[silentOptionName].(bool)
        chunker, _ := req.Options[chunkerOptionName].(string)
        dopin, _ := req.Options[pinOptionName].(bool)
        rawblks, rbset := req.Options[rawLeavesOptionName].(bool)
        nocopy, _ := req.Options[noCopyOptionName].(bool)
        fscache, _ := req.Options[fstoreCacheOptionName].(bool)
        cidVer, cidVerSet := req.Options[cidVersionOptionName].(int)
        hashFunStr, _ := req.Options[hashOptionName].(string)
        inline, _ := req.Options[inlineOptionName].(bool)
        inlineLimit, _ := req.Options[inlineLimitOptionName].(int)

        hashFunCode, ok := mh.Names[strings.ToLower(hashFunStr)]
        if !ok {
            return fmt.Errorf("unrecognized hash function: %s", strings.ToLower(hashFunStr))
        }

        enc, err := cmdenv.GetCidEncoder(req)
        if err != nil {
            return err
        }

        toadd := req.Files
        if wrap {
            toadd = files.NewSliceDirectory([]files.DirEntry{
                files.FileEntry("", req.Files),
            })
        }

        opts := []options.UnixfsAddOption{
            options.Unixfs.Hash(hashFunCode),

            options.Unixfs.Inline(inline),
            options.Unixfs.InlineLimit(inlineLimit),

            options.Unixfs.Chunker(chunker),

            options.Unixfs.Pin(dopin),
            options.Unixfs.HashOnly(hash),
            options.Unixfs.FsCache(fscache),
            options.Unixfs.Nocopy(nocopy),

            options.Unixfs.Progress(progress),
            options.Unixfs.Silent(silent),
        }

        if cidVerSet {
            opts = append(opts, options.Unixfs.CidVersion(cidVer))
        }

        if rbset {
            opts = append(opts, options.Unixfs.RawLeaves(rawblks))
        }

        if trickle {
            opts = append(opts, options.Unixfs.Layout(options.TrickleLayout))
        }

        opts = append(opts, nil)

        var added int
        addit := toadd.Entries()
        for addit.Next() {
            _, dir := addit.Node().(files.Directory)
            errCh := make(chan error, 1)
            events := make(chan interface{}, adderOutChanSize)
            opts[len(opts)-1] = options.Unixfs.Events(events)

            go func() {
                var err error
                defer close(events)
                _, err = api.Unixfs().Add(req.Context, addit.Node(), opts...)
                errCh <- err
            }()

            for event := range events {
                output, ok := event.(*coreiface.AddEvent)
                if !ok {
                    return errors.New("unknown event type")
                }

                h := ""
                if output.Path != nil {
                    h = enc.Encode(output.Path.Cid())
                }

                if !dir && addit.Name() != "" {
                    output.Name = addit.Name()
                } else {
                    output.Name = path.Join(addit.Name(), output.Name)
                }

                if err := res.Emit(&AddEvent{
                    Name:  output.Name,
                    Hash:  h,
                    Bytes: output.Bytes,
                    Size:  output.Size,
                }); err != nil {
                    return err
                }
            }

            if err := <-errCh; err != nil {
                return err
            }
            added++
        }

        if addit.Err() != nil {
            return addit.Err()
        }

        if added == 0 {
            return fmt.Errorf("expected a file argument")
        }

        return nil
    },
    PostRun: cmds.PostRunMap{
        cmds.CLI: func(res cmds.Response, re cmds.ResponseEmitter) error {
            sizeChan := make(chan int64, 1)
            outChan := make(chan interface{})
            req := res.Request()

            go func() {
                size, err := req.Files.Size()
                if err != nil {
                    log.Warningf("error getting files size: %s", err)

                    return
                }

                sizeChan <- size
            }()

            progressBar := func(wait chan struct{}) {
                defer close(wait)

                quiet, _ := req.Options[quietOptionName].(bool)
                quieter, _ := req.Options[quieterOptionName].(bool)
                quiet = quiet || quieter

                progress, _ := req.Options[progressOptionName].(bool)

                var bar *pb.ProgressBar
                if progress {
                    bar = pb.New64(0).SetUnits(pb.U_BYTES)
                    bar.ManualUpdate = true
                    bar.ShowTimeLeft = false
                    bar.ShowPercent = false
                    bar.Output = os.Stderr
                    bar.Start()
                }

                lastFile := ""
                lastHash := ""
                var totalProgress, prevFiles, lastBytes int64

            LOOP:
                for {
                    select {
                    case out, ok := <-outChan:
                        if !ok {
                            if quieter {
                                fmt.Fprintln(os.Stdout, lastHash)
                            }

                            break LOOP
                        }
                        output := out.(*AddEvent)
                        if len(output.Hash) > 0 {
                            lastHash = output.Hash
                            if quieter {
                                continue
                            }

                            if progress {

                                fmt.Fprintf(os.Stderr, "\033[2K\r")
                            }
                            if quiet {
                                fmt.Fprintf(os.Stdout, "%s\n", output.Hash)
                            } else {
                                fmt.Fprintf(os.Stdout, "added %s %s\n", output.Hash, output.Name)
                            }

                        } else {
                            if !progress {
                                continue
                            }

                            if len(lastFile) == 0 {
                                lastFile = output.Name
                            }
                            if output.Name != lastFile || output.Bytes < lastBytes {
                                prevFiles += lastBytes
                                lastFile = output.Name
                            }
                            lastBytes = output.Bytes
                            delta := prevFiles + lastBytes - totalProgress
                            totalProgress = bar.Add64(delta)
                        }

                        if progress {
                            bar.Update()
                        }
                    case size := <-sizeChan:
                        if progress {
                            bar.Total = size
                            bar.ShowPercent = true
                            bar.ShowBar = true
                            bar.ShowTimeLeft = true
                        }
                    case <-req.Context.Done():

                        return
                    }
                }

                if progress && bar.Total == 0 && bar.Get() != 0 {
                    bar.Total = bar.Get()
                    bar.ShowPercent = true
                    bar.ShowBar = true
                    bar.ShowTimeLeft = true
                    bar.Update()
                }
            }

            if e := res.Error(); e != nil {
                close(outChan)
                return e
            }

            wait := make(chan struct{})
            go progressBar(wait)

            defer func() { <-wait }()
            defer close(outChan)

            for {
                v, err := res.Next()
                if err != nil {
                    if err == io.EOF {
                        return nil
                    }

                    return err
                }

                select {
                case outChan <- v:
                case <-req.Context.Done():
                    return req.Context.Err()
                }
            }
        },
    },
    Type: AddEvent{},
}
var BitswapCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "Interact with the bitswap agent.",
        ShortDescription: ``,
    },

    Subcommands: map[string]*cmds.Command{
        "stat":      bitswapStatCmd,
        "wantlist":  showWantlistCmd,
        "ledger":    ledgerCmd,
        "reprovide": reprovideCmd,
    },
}
var BlockCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "Interact with raw IPFS blocks.",
        ShortDescription: "" /* 153 byte string literal not displayed */,
    },

    Subcommands: map[string]*cmds.Command{
        "stat": blockStatCmd,
        "get":  blockGetCmd,
        "put":  blockPutCmd,
        "rm":   blockRmCmd,
    },
}
var BootstrapCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline: "Show or edit the list of bootstrap peers.",
        ShortDescription: `
Running 'ipfs bootstrap' with no arguments will run 'ipfs bootstrap list'.
` + bootstrapSecurityWarning,
    },

    Run:      bootstrapListCmd.Run,
    Encoders: bootstrapListCmd.Encoders,
    Type:     bootstrapListCmd.Type,

    Subcommands: map[string]*cmds.Command{
        "list": bootstrapListCmd,
        "add":  bootstrapAddCmd,
        "rm":   bootstrapRemoveCmd,
    },
}
var CatCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "Show IPFS object data.",
        ShortDescription: "Displays the data contained by an IPFS or IPNS object(s) at the given path.",
    },

    Arguments: []cmds.Argument{
        cmds.StringArg("ipfs-path", true, true, "The path to the IPFS object(s) to be outputted.").EnableStdin(),
    },
    Options: []cmds.Option{
        cmds.Int64Option(offsetOptionName, "o", "Byte offset to begin reading from."),
        cmds.Int64Option(lengthOptionName, "l", "Maximum number of bytes to read."),
    },
    Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
        api, err := cmdenv.GetApi(env, req)
        if err != nil {
            return err
        }

        offset, _ := req.Options[offsetOptionName].(int64)
        if offset < 0 {
            return fmt.Errorf("cannot specify negative offset")
        }

        max, found := req.Options[lengthOptionName].(int64)

        if max < 0 {
            return fmt.Errorf("cannot specify negative length")
        }
        if !found {
            max = -1
        }

        err = req.ParseBodyArgs()
        if err != nil {
            return err
        }

        readers, length, err := cat(req.Context, api, req.Arguments, int64(offset), int64(max))
        if err != nil {
            return err
        }

        res.SetLength(length)
        reader := io.MultiReader(readers...)

        return res.Emit(reader)
    },
    PostRun: cmds.PostRunMap{
        cmds.CLI: func(res cmds.Response, re cmds.ResponseEmitter) error {
            if res.Length() > 0 && res.Length() < progressBarMinSize {
                return cmds.Copy(re, res)
            }

            for {
                v, err := res.Next()
                if err != nil {
                    if err == io.EOF {
                        return nil
                    }
                    return err
                }

                switch val := v.(type) {
                case io.Reader:
                    bar, reader := progressBarForReader(os.Stderr, val, int64(res.Length()))
                    bar.Start()

                    err = re.Emit(reader)
                    if err != nil {
                        return err
                    }
                default:
                    log.Warningf("cat postrun: received unexpected type %T", val)
                }
            }
        },
    },
}
var CidCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline: "Convert and discover properties of CIDs",
    },
    Subcommands: map[string]*cmds.Command{
        "format": cidFmtCmd,
        "base32": base32Cmd,
        "bases":  basesCmd,
        "codecs": codecsCmd,
        "hashes": hashesCmd,
    },
}
var CommandsDaemonCmd = CommandsCmd(Root)

commandsDaemonCmd is the "ipfs commands" command for daemon

var CommandsDaemonROCmd = CommandsCmd(RootRO)
var ConfigCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "Get and set ipfs config values.",
        ShortDescription: "" /* 160 byte string literal not displayed */,

        LongDescription: "" /* 347 byte string literal not displayed */,
    },
    Subcommands: map[string]*cmds.Command{
        "show":    configShowCmd,
        "edit":    configEditCmd,
        "replace": configReplaceCmd,
        "profile": configProfileCmd,
    },
    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."),
    },
    Options: []cmds.Option{
        cmds.BoolOption(configBoolOptionName, "Set a boolean value."),
        cmds.BoolOption(configJSONOptionName, "Parse stringified JSON."),
    },
    Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
        args := req.Arguments
        key := args[0]

        var output *ConfigField

        switch strings.ToLower(key) {
        case "identity", "identity.privkey":
            return errors.New("cannot show or change private key through API")
        default:
        }

        cfgRoot, err := cmdenv.GetConfigRoot(env)
        if err != nil {
            return err
        }
        r, err := fsrepo.Open(cfgRoot)
        if err != nil {
            return err
        }
        defer r.Close()
        if len(args) == 2 {
            value := args[1]

            if parseJSON, _ := req.Options[configJSONOptionName].(bool); parseJSON {
                var jsonVal interface{}
                if err := json.Unmarshal([]byte(value), &jsonVal); err != nil {
                    err = fmt.Errorf("failed to unmarshal json. %s", err)
                    return err
                }

                output, err = setConfig(r, key, jsonVal)
            } else if isbool, _ := req.Options[configBoolOptionName].(bool); isbool {
                output, err = setConfig(r, key, value == "true")
            } else {
                output, err = setConfig(r, key, value)
            }
        } else {
            output, err = getConfig(r, key)
        }

        if err != nil {
            return err
        }

        return cmds.EmitOnce(res, output)
    },
    Encoders: cmds.EncoderMap{
        cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, out *ConfigField) error {
            if len(req.Arguments) == 2 {
                return nil
            }

            buf, err := config.HumanOutput(out.Value)
            if err != nil {
                return err
            }
            buf = append(buf, byte('\n'))

            _, err = w.Write(buf)
            return err
        }),
    },
    Type: ConfigField{},
}
var DNSCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "Resolve DNS links.",
        ShortDescription: "" /* 266 byte string literal not displayed */,

        LongDescription: "" /* 877 byte string literal not displayed */,
    },

    Arguments: []cmds.Argument{
        cmds.StringArg("domain-name", true, false, "The domain-name name to resolve.").EnableStdin(),
    },
    Options: []cmds.Option{
        cmds.BoolOption(dnsRecursiveOptionName, "r", "Resolve until the result is not a DNS link.").WithDefault(true),
    },
    Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
        recursive, _ := req.Options[dnsRecursiveOptionName].(bool)
        name := req.Arguments[0]
        resolver := namesys.NewDNSResolver()

        var routing []nsopts.ResolveOpt
        if !recursive {
            routing = append(routing, nsopts.Depth(1))
        }

        output, err := resolver.Resolve(req.Context, name, routing...)
        if err != nil && (recursive || err != namesys.ErrResolveRecursion) {
            return err
        }
        return cmds.EmitOnce(res, &ncmd.ResolvedPath{Path: output})
    },
    Encoders: cmds.EncoderMap{
        cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, out *ncmd.ResolvedPath) error {
            fmt.Fprintln(w, out.Path.String())
            return nil
        }),
    },
    Type: ncmd.ResolvedPath{},
}
var DefaultBufSize = 1048576

DefaultBufSize is the buffer size for gets. for now, 1MB, which is ~4 blocks. TODO: does this need to be configurable?

var DhtCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "Issue commands directly through the DHT.",
        ShortDescription: ``,
    },

    Subcommands: map[string]*cmds.Command{
        "query":     queryDhtCmd,
        "findprovs": findProvidersDhtCmd,
        "findpeer":  findPeerDhtCmd,
        "get":       getValueDhtCmd,
        "put":       putValueDhtCmd,
        "provide":   provideRefDhtCmd,
    },
}
var DiagCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline: "Generate diagnostic reports.",
    },

    Subcommands: map[string]*cmds.Command{
        "sys":  sysDiagCmd,
        "cmds": ActiveReqsCmd,
    },
}
var ErrDepthLimitExceeded = fmt.Errorf("depth limit exceeded")

ErrDepthLimitExceeded indicates that the max depth has been exceeded.

var ErrInvalidCompressionLevel = errors.New("compression level must be between 1 and 9")
var ErrNotDHT = errors.New("routing service is not a DHT")
var ErrNotOnline = errors.New("this command must be run in online mode. Try running 'ipfs daemon' first")
var ErrPingSelf = errors.New("error: can't ping self")

ErrPingSelf is returned when the user attempts to ping themself.

var FileStoreCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline: "Interact with filestore objects.",
    },
    Subcommands: map[string]*cmds.Command{
        "ls":     lsFileStore,
        "verify": verifyFileStore,
        "dups":   dupsFileStore,
    },
}
var FilesCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "Interact with unixfs files.",
        ShortDescription: "" /* 554 byte string literal not displayed */,
    },
    Options: []cmds.Option{
        cmds.BoolOption(filesFlushOptionName, "f", "Flush target and ancestors after write.").WithDefault(true),
    },
    Subcommands: map[string]*cmds.Command{
        "read":  filesReadCmd,
        "write": filesWriteCmd,
        "mv":    filesMvCmd,
        "cp":    filesCpCmd,
        "ls":    filesLsCmd,
        "mkdir": filesMkdirCmd,
        "stat":  filesStatCmd,
        "rm":    filesRmCmd,
        "flush": filesFlushCmd,
        "chcid": filesChcidCmd,
    },
}

FilesCmd is the 'ipfs files' command

var GetCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "Download IPFS objects.",
        ShortDescription: "" /* 441 byte string literal not displayed */,
    },

    Arguments: []cmds.Argument{
        cmds.StringArg("ipfs-path", true, false, "The path to the IPFS object(s) to be outputted.").EnableStdin(),
    },
    Options: []cmds.Option{
        cmds.StringOption(outputOptionName, "o", "The path where the output should be stored."),
        cmds.BoolOption(archiveOptionName, "a", "Output a TAR archive."),
        cmds.BoolOption(compressOptionName, "C", "Compress the output with GZIP compression."),
        cmds.IntOption(compressionLevelOptionName, "l", "The level of compression (1-9)."),
    },
    PreRun: func(req *cmds.Request, env cmds.Environment) error {
        _, err := getCompressOptions(req)
        return err
    },
    Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
        cmplvl, err := getCompressOptions(req)
        if err != nil {
            return err
        }

        api, err := cmdenv.GetApi(env, req)
        if err != nil {
            return err
        }

        p := path.New(req.Arguments[0])

        file, err := api.Unixfs().Get(req.Context, p)
        if err != nil {
            return err
        }

        size, err := file.Size()
        if err != nil {
            return err
        }

        res.SetLength(uint64(size))

        archive, _ := req.Options[archiveOptionName].(bool)
        reader, err := fileArchive(file, p.String(), archive, cmplvl)
        if err != nil {
            return err
        }

        return res.Emit(reader)
    },
    PostRun: cmds.PostRunMap{
        cmds.CLI: func(res cmds.Response, re cmds.ResponseEmitter) error {
            req := res.Request()

            v, err := res.Next()
            if err != nil {
                return err
            }

            outReader, ok := v.(io.Reader)
            if !ok {
                return e.New(e.TypeErr(outReader, v))
            }

            outPath := getOutPath(req)

            cmplvl, err := getCompressOptions(req)
            if err != nil {
                return err
            }

            archive, _ := req.Options[archiveOptionName].(bool)

            gw := getWriter{
                Out:         os.Stdout,
                Err:         os.Stderr,
                Archive:     archive,
                Compression: cmplvl,
                Size:        int64(res.Length()),
            }

            return gw.Write(outReader, outPath)
        },
    },
}
var IDCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "Show ipfs node id info.",
        ShortDescription: "" /* 408 byte string literal not displayed */,
    },
    Arguments: []cmds.Argument{
        cmds.StringArg("peerid", false, false, "Peer.ID of node to look up."),
    },
    Options: []cmds.Option{
        cmds.StringOption(formatOptionName, "f", "Optional output format."),
    },
    Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
        n, err := cmdenv.GetNode(env)
        if err != nil {
            return err
        }

        var id peer.ID
        if len(req.Arguments) > 0 {
            var err error
            id, err = peer.IDB58Decode(req.Arguments[0])
            if err != nil {
                return fmt.Errorf("invalid peer id")
            }
        } else {
            id = n.Identity
        }

        if id == n.Identity {
            output, err := printSelf(n)
            if err != nil {
                return err
            }
            return cmds.EmitOnce(res, output)
        }

        if !n.IsOnline {
            return errors.New(offlineIdErrorMessage)
        }

        p, err := n.Routing.FindPeer(req.Context, id)
        if err == kb.ErrLookupFailure {
            return errors.New(offlineIdErrorMessage)
        }
        if err != nil {
            return err
        }

        output, err := printPeer(n.Peerstore, p.ID)
        if err != nil {
            return err
        }
        return cmds.EmitOnce(res, output)
    },
    Encoders: cmds.EncoderMap{
        cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, out *IdOutput) error {
            format, found := req.Options[formatOptionName].(string)
            if found {
                output := format
                output = strings.Replace(output, "<id>", out.ID, -1)
                output = strings.Replace(output, "<aver>", out.AgentVersion, -1)
                output = strings.Replace(output, "<pver>", out.ProtocolVersion, -1)
                output = strings.Replace(output, "<pubkey>", out.PublicKey, -1)
                output = strings.Replace(output, "<addrs>", strings.Join(out.Addresses, "\n"), -1)
                output = strings.Replace(output, "\\n", "\n", -1)
                output = strings.Replace(output, "\\t", "\t", -1)
                fmt.Fprint(w, output)
            } else {
                marshaled, err := json.MarshalIndent(out, "", "\t")
                if err != nil {
                    return err
                }
                marshaled = append(marshaled, byte('\n'))
                fmt.Fprintln(w, string(marshaled))
            }
            return nil
        }),
    },
    Type: IdOutput{},
}
var KeyCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "Create and list IPNS name keypairs",
        ShortDescription: "" /* 258 byte string literal not displayed */,
    },
    Subcommands: map[string]*cmds.Command{
        "gen":    keyGenCmd,
        "list":   keyListCmd,
        "rename": keyRenameCmd,
        "rm":     keyRmCmd,
    },
}
var LogCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "Interact with the daemon log output.",
        ShortDescription: "" /* 414 byte string literal not displayed */,
    },

    Subcommands: map[string]*cmds.Command{
        "level": logLevelCmd,
        "ls":    logLsCmd,
        "tail":  logTailCmd,
    },
}
var LsCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "List directory contents for Unix filesystem objects.",
        ShortDescription: "" /* 199 byte string literal not displayed */,
    },

    Arguments: []cmds.Argument{
        cmds.StringArg("ipfs-path", true, true, "The path to the IPFS object(s) to list links from.").EnableStdin(),
    },
    Options: []cmds.Option{
        cmds.BoolOption(lsHeadersOptionNameTime, "v", "Print table headers (Hash, Size, Name)."),
        cmds.BoolOption(lsResolveTypeOptionName, "Resolve linked objects to find out their types.").WithDefault(true),
        cmds.BoolOption(lsSizeOptionName, "Resolve linked objects to find out their file size.").WithDefault(true),
        cmds.BoolOption(lsStreamOptionName, "s", "Enable experimental streaming of directory entries as they are traversed."),
    },
    Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
        api, err := cmdenv.GetApi(env, req)
        if err != nil {
            return err
        }

        resolveType, _ := req.Options[lsResolveTypeOptionName].(bool)
        resolveSize, _ := req.Options[lsSizeOptionName].(bool)
        stream, _ := req.Options[lsStreamOptionName].(bool)

        err = req.ParseBodyArgs()
        if err != nil {
            return err
        }
        paths := req.Arguments

        enc, err := cmdenv.GetCidEncoder(req)
        if err != nil {
            return err
        }

        var processLink func(path string, link LsLink) error
        var dirDone func(i int)

        processDir := func() (func(path string, link LsLink) error, func(i int)) {
            return func(path string, link LsLink) error {
                output := []LsObject{{
                    Hash:  path,
                    Links: []LsLink{link},
                }}
                return res.Emit(&LsOutput{output})
            }, func(i int) {}
        }
        done := func() error { return nil }

        if !stream {
            output := make([]LsObject, len(req.Arguments))

            processDir = func() (func(path string, link LsLink) error, func(i int)) {

                outputLinks := make([]LsLink, 0)
                return func(path string, link LsLink) error {

                        outputLinks = append(outputLinks, link)
                        return nil
                    }, func(i int) {

                        sort.Slice(outputLinks, func(i, j int) bool {
                            return outputLinks[i].Name < outputLinks[j].Name
                        })

                        output[i] = LsObject{
                            Hash:  paths[i],
                            Links: outputLinks,
                        }
                    }
            }

            done = func() error {
                return cmds.EmitOnce(res, &LsOutput{output})
            }
        }

        for i, fpath := range paths {
            results, err := api.Unixfs().Ls(req.Context, path.New(fpath),
                options.Unixfs.ResolveChildren(resolveSize || resolveType))
            if err != nil {
                return err
            }

            processLink, dirDone = processDir()
            for link := range results {
                if link.Err != nil {
                    return link.Err
                }
                var ftype unixfs_pb.Data_DataType
                switch link.Type {
                case iface.TFile:
                    ftype = unixfs.TFile
                case iface.TDirectory:
                    ftype = unixfs.TDirectory
                case iface.TSymlink:
                    ftype = unixfs.TSymlink
                }
                lsLink := LsLink{
                    Name: link.Name,
                    Hash: enc.Encode(link.Cid),

                    Size:   link.Size,
                    Type:   ftype,
                    Target: link.Target,
                }
                if err := processLink(paths[i], lsLink); err != nil {
                    return err
                }
            }
            dirDone(i)
        }
        return done()
    },
    PostRun: cmds.PostRunMap{
        cmds.CLI: func(res cmds.Response, re cmds.ResponseEmitter) error {
            req := res.Request()
            lastObjectHash := ""

            for {
                v, err := res.Next()
                if err != nil {
                    if err == io.EOF {
                        return nil
                    }
                    return err
                }
                out := v.(*LsOutput)
                lastObjectHash = tabularOutput(req, os.Stdout, out, lastObjectHash, false)
            }
        },
    },
    Encoders: cmds.EncoderMap{
        cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, out *LsOutput) error {

            ignoreBreaks, _ := req.Options[lsStreamOptionName].(bool)
            tabularOutput(req, w, out, "", ignoreBreaks)
            return nil
        }),
    },
    Type: LsOutput{},
}
var MountCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "Mounts IPFS to the filesystem (read-only).",
        ShortDescription: "" /* 381 byte string literal not displayed */,

        LongDescription: "" /* 1114 byte string literal not displayed */,
    },
    Options: []cmds.Option{
        cmds.StringOption(mountIPFSPathOptionName, "f", "The path where IPFS should be mounted."),
        cmds.StringOption(mountIPNSPathOptionName, "n", "The path where IPNS should be mounted."),
    },
    Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
        cfg, err := cmdenv.GetConfig(env)
        if err != nil {
            return err
        }

        nd, err := cmdenv.GetNode(env)
        if err != nil {
            return err
        }

        if !nd.IsOnline {
            return ErrNotOnline
        }

        fsdir, found := req.Options[mountIPFSPathOptionName].(string)
        if !found {
            fsdir = cfg.Mounts.IPFS
        }

        nsdir, found := req.Options[mountIPNSPathOptionName].(string)
        if !found {
            nsdir = cfg.Mounts.IPNS
        }

        err = nodeMount.Mount(nd, fsdir, nsdir)
        if err != nil {
            return err
        }

        var output config.Mounts
        output.IPFS = fsdir
        output.IPNS = nsdir
        return cmds.EmitOnce(res, &output)
    },
    Type: config.Mounts{},
    Encoders: cmds.EncoderMap{
        cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, mounts *config.Mounts) error {
            fmt.Fprintf(w, "IPFS mounted at: %s\n", mounts.IPFS)
            fmt.Fprintf(w, "IPNS mounted at: %s\n", mounts.IPNS)

            return nil
        }),
    },
}
var P2PCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "Libp2p stream mounting.",
        ShortDescription: "" /* 144 byte string literal not displayed */,
    },

    Subcommands: map[string]*cmds.Command{
        "stream":  p2pStreamCmd,
        "forward": p2pForwardCmd,
        "listen":  p2pListenCmd,
        "close":   p2pCloseCmd,
        "ls":      p2pLsCmd,
    },
}

P2PCmd is the 'ipfs p2p' command

var PinCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline: "Pin (and unpin) objects to local storage.",
    },

    Subcommands: map[string]*cmds.Command{
        "add":    addPinCmd,
        "rm":     rmPinCmd,
        "ls":     listPinCmd,
        "verify": verifyPinCmd,
        "update": updatePinCmd,
    },
}
var PingCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "Send echo request packets to IPFS hosts.",
        ShortDescription: "" /* 181 byte string literal not displayed */,
    },
    Arguments: []cmds.Argument{
        cmds.StringArg("peer ID", true, true, "ID of peer to be pinged.").EnableStdin(),
    },
    Options: []cmds.Option{
        cmds.IntOption(pingCountOptionName, "n", "Number of ping messages to send.").WithDefault(10),
    },
    Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
        n, err := cmdenv.GetNode(env)
        if err != nil {
            return err
        }

        if !n.IsOnline {
            return ErrNotOnline
        }

        addr, pid, err := ParsePeerParam(req.Arguments[0])
        if err != nil {
            return fmt.Errorf("failed to parse peer address '%s': %s", req.Arguments[0], err)
        }

        if pid == n.Identity {
            return ErrPingSelf
        }

        if addr != nil {
            n.Peerstore.AddAddr(pid, addr, pstore.TempAddrTTL)
        }

        numPings, _ := req.Options[pingCountOptionName].(int)
        if numPings <= 0 {
            return fmt.Errorf("ping count must be greater than 0, was %d", numPings)
        }

        if len(n.Peerstore.Addrs(pid)) == 0 {

            if err := res.Emit(&PingResult{
                Text:    fmt.Sprintf("Looking up peer %s", pid.Pretty()),
                Success: true,
            }); err != nil {
                return err
            }

            ctx, cancel := context.WithTimeout(req.Context, kPingTimeout)
            p, err := n.Routing.FindPeer(ctx, pid)
            cancel()
            if err != nil {
                return fmt.Errorf("peer lookup failed: %s", err)
            }
            n.Peerstore.AddAddrs(p.ID, p.Addrs, pstore.TempAddrTTL)
        }

        if err := res.Emit(&PingResult{
            Text:    fmt.Sprintf("PING %s.", pid.Pretty()),
            Success: true,
        }); err != nil {
            return err
        }

        ctx, cancel := context.WithTimeout(req.Context, kPingTimeout*time.Duration(numPings))
        defer cancel()
        pings := ping.Ping(ctx, n.PeerHost, pid)

        var (
            count int
            total time.Duration
        )
        ticker := time.NewTicker(time.Second)
        defer ticker.Stop()

        for i := 0; i < numPings; i++ {
            r, ok := <-pings
            if !ok {
                break
            }

            if r.Error != nil {
                err = res.Emit(&PingResult{
                    Success: false,
                    Text:    fmt.Sprintf("Ping error: %s", r.Error),
                })
            } else {
                count++
                total += r.RTT
                err = res.Emit(&PingResult{
                    Success: true,
                    Time:    r.RTT,
                })
            }
            if err != nil {
                return err
            }

            select {
            case <-ticker.C:
            case <-ctx.Done():
                return ctx.Err()
            }
        }
        if count == 0 {
            return fmt.Errorf("ping failed")
        }
        averagems := total.Seconds() * 1000 / float64(count)
        return res.Emit(&PingResult{
            Success: true,
            Text:    fmt.Sprintf("Average latency: %.2fms", averagems),
        })
    },
    Type: PingResult{},
    PostRun: cmds.PostRunMap{
        cmds.CLI: func(res cmds.Response, re cmds.ResponseEmitter) error {
            var (
                total time.Duration
                count int
            )

            for {
                event, err := res.Next()
                switch err {
                case nil:
                case io.EOF:
                    return nil
                case context.Canceled, context.DeadlineExceeded:
                    if count == 0 {
                        return err
                    }
                    averagems := total.Seconds() * 1000 / float64(count)
                    return re.Emit(&PingResult{
                        Success: true,
                        Text:    fmt.Sprintf("Average latency: %.2fms", averagems),
                    })
                default:
                    return err
                }

                pr := event.(*PingResult)
                if pr.Success && pr.Text == "" {
                    total += pr.Time
                    count++
                }
                err = re.Emit(event)
                if err != nil {
                    return err
                }
            }
        },
    },
    Encoders: cmds.EncoderMap{
        cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, out *PingResult) error {
            if len(out.Text) > 0 {
                fmt.Fprintln(w, out.Text)
            } else if out.Success {
                fmt.Fprintf(w, "Pong received: time=%.2f ms\n", out.Time.Seconds()*1000)
            } else {
                fmt.Fprintf(w, "Pong failed\n")
            }
            return nil
        }),
    },
}
var PubsubCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "An experimental publish-subscribe system on ipfs.",
        ShortDescription: "" /* 301 byte string literal not displayed */,
    },
    Subcommands: map[string]*cmds.Command{
        "pub":   PubsubPubCmd,
        "sub":   PubsubSubCmd,
        "ls":    PubsubLsCmd,
        "peers": PubsubPeersCmd,
    },
}
var PubsubLsCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "List subscribed topics by name.",
        ShortDescription: "" /* 262 byte string literal not displayed */,
    },
    Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
        api, err := cmdenv.GetApi(env, req)
        if err != nil {
            return err
        }

        l, err := api.PubSub().Ls(req.Context)
        if err != nil {
            return err
        }

        return cmds.EmitOnce(res, stringList{l})
    },
    Type: stringList{},
    Encoders: cmds.EncoderMap{
        cmds.Text: cmds.MakeTypedEncoder(stringListEncoder),
    },
}
var PubsubPeersCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "List peers we are currently pubsubbing with.",
        ShortDescription: "" /* 365 byte string literal not displayed */,
    },
    Arguments: []cmds.Argument{
        cmds.StringArg("topic", false, false, "topic to list connected peers of"),
    },
    Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
        api, err := cmdenv.GetApi(env, req)
        if err != nil {
            return err
        }

        var topic string
        if len(req.Arguments) == 1 {
            topic = req.Arguments[0]
        }

        peers, err := api.PubSub().Peers(req.Context, options.PubSub.Topic(topic))
        if err != nil {
            return err
        }

        list := &stringList{make([]string, 0, len(peers))}

        for _, peer := range peers {
            list.Strings = append(list.Strings, peer.Pretty())
        }
        sort.Strings(list.Strings)
        return cmds.EmitOnce(res, list)
    },
    Type: stringList{},
    Encoders: cmds.EncoderMap{
        cmds.Text: cmds.MakeTypedEncoder(stringListEncoder),
    },
}
var PubsubPubCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "Publish a message to a given pubsub topic.",
        ShortDescription: "" /* 242 byte string literal not displayed */,
    },
    Arguments: []cmds.Argument{
        cmds.StringArg("topic", true, false, "Topic to publish to."),
        cmds.StringArg("data", true, true, "Payload of message to publish.").EnableStdin(),
    },
    Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
        api, err := cmdenv.GetApi(env, req)
        if err != nil {
            return err
        }

        topic := req.Arguments[0]

        err = req.ParseBodyArgs()
        if err != nil {
            return err
        }

        for _, data := range req.Arguments[1:] {
            if err := api.PubSub().Publish(req.Context, topic, []byte(data)); err != nil {
                return err
            }
        }

        return nil
    },
}
var PubsubSubCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "Subscribe to messages on a given topic.",
        ShortDescription: "" /* 241 byte string literal not displayed */,

        LongDescription: "" /* 355 byte string literal not displayed */,
    },
    Arguments: []cmds.Argument{
        cmds.StringArg("topic", true, false, "String name of topic to subscribe to."),
    },
    Options: []cmds.Option{
        cmds.BoolOption(pubsubDiscoverOptionName, "try to discover other peers subscribed to the same topic"),
    },
    Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
        api, err := cmdenv.GetApi(env, req)
        if err != nil {
            return err
        }

        topic := req.Arguments[0]
        discover, _ := req.Options[pubsubDiscoverOptionName].(bool)

        sub, err := api.PubSub().Subscribe(req.Context, topic, options.PubSub.Discover(discover))
        if err != nil {
            return err
        }
        defer sub.Close()

        if f, ok := res.(http.Flusher); ok {
            f.Flush()
        }

        for {
            msg, err := sub.Next(req.Context)
            if err == io.EOF || err == context.Canceled {
                return nil
            } else if err != nil {
                return err
            }

            if err := res.Emit(&pubsubMessage{
                Data:     msg.Data(),
                From:     []byte(msg.From()),
                Seqno:    msg.Seq(),
                TopicIDs: msg.Topics(),
            }); err != nil {
                return err
            }
        }
    },
    Encoders: cmds.EncoderMap{
        cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, psm *pubsubMessage) error {
            _, err := w.Write(psm.Data)
            return err
        }),
        "ndpayload": cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, psm *pubsubMessage) error {
            psm.Data = append(psm.Data, '\n')
            _, err := w.Write(psm.Data)
            return err
        }),
        "lenpayload": cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, psm *pubsubMessage) error {
            buf := make([]byte, 8, len(psm.Data)+8)

            n := binary.PutUvarint(buf, uint64(len(psm.Data)))
            buf = append(buf[:n], psm.Data...)
            _, err := w.Write(buf)
            return err
        }),
    },
    Type: pubsubMessage{},
}
var RefsCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "List links (references) from an object.",
        ShortDescription: "" /* 185 byte string literal not displayed */,
    },
    Subcommands: map[string]*cmds.Command{
        "local": RefsLocalCmd,
    },
    Arguments: []cmds.Argument{
        cmds.StringArg("ipfs-path", true, true, "Path to the object(s) to list refs from.").EnableStdin(),
    },
    Options: []cmds.Option{
        cmds.StringOption(refsFormatOptionName, "Emit edges with given format. Available tokens: <src> <dst> <linkname>.").WithDefault("<dst>"),
        cmds.BoolOption(refsEdgesOptionName, "e", "Emit edge format: `<from> -> <to>`."),
        cmds.BoolOption(refsUniqueOptionName, "u", "Omit duplicate refs from output."),
        cmds.BoolOption(refsRecursiveOptionName, "r", "Recursively list links of child nodes."),
        cmds.IntOption(refsMaxDepthOptionName, "Only for recursive refs, limits fetch and listing to the given depth").WithDefault(-1),
    },
    Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
        err := req.ParseBodyArgs()
        if err != nil {
            return err
        }

        ctx := req.Context
        api, err := cmdenv.GetApi(env, req)
        if err != nil {
            return err
        }

        enc, err := cmdenv.GetCidEncoder(req)
        if err != nil {
            return err
        }

        unique, _ := req.Options[refsUniqueOptionName].(bool)
        recursive, _ := req.Options[refsRecursiveOptionName].(bool)
        maxDepth, _ := req.Options[refsMaxDepthOptionName].(int)
        edges, _ := req.Options[refsEdgesOptionName].(bool)
        format, _ := req.Options[refsFormatOptionName].(string)

        if !recursive {
            maxDepth = 1
        }

        if edges {
            if format != "<dst>" {
                return errors.New("using format argument with edges is not allowed")
            }

            format = "<src> -> <dst>"
        }

        objs, err := objectsForPaths(ctx, api, req.Arguments)
        if err != nil {
            return err
        }

        rw := RefWriter{
            res:      res,
            DAG:      api.Dag(),
            Ctx:      ctx,
            Unique:   unique,
            PrintFmt: format,
            MaxDepth: maxDepth,
        }

        for _, o := range objs {
            if _, err := rw.WriteRefs(o, enc); err != nil {
                if err := res.Emit(&RefWrapper{Err: err.Error()}); err != nil {
                    return err
                }
            }
        }

        return nil
    },
    Encoders: refsEncoderMap,
    Type:     RefWrapper{},
}

RefsCmd is the `ipfs refs` command

var RefsLocalCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline: "List all local references.",
        ShortDescription: `
Displays the hashes of all local objects.
`,
    },

    Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
        ctx := req.Context
        n, err := cmdenv.GetNode(env)
        if err != nil {
            return err
        }

        allKeys, err := n.Blockstore.AllKeysChan(ctx)
        if err != nil {
            return err
        }

        for k := range allKeys {
            err := res.Emit(&RefWrapper{Ref: k.String()})
            if err != nil {
                return err
            }
        }

        return nil
    },
    Encoders: refsEncoderMap,
    Type:     RefWrapper{},
}
var RefsROCmd = &cmds.Command{}

RefsROCmd is `ipfs refs` command

var RepoCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline: "Manipulate the IPFS repo.",
        ShortDescription: `
'ipfs repo' is a plumbing command used to manipulate the repo.
`,
    },

    Subcommands: map[string]*cmds.Command{
        "stat":    repoStatCmd,
        "gc":      repoGcCmd,
        "fsck":    repoFsckCmd,
        "version": repoVersionCmd,
        "verify":  repoVerifyCmd,
    },
}
var ResolveCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "Resolve the value of names to IPFS.",
        ShortDescription: "" /* 182 byte string literal not displayed */,

        LongDescription: "" /* 1015 byte string literal not displayed */,
    },

    Arguments: []cmds.Argument{
        cmds.StringArg("name", true, false, "The name to resolve.").EnableStdin(),
    },
    Options: []cmds.Option{
        cmds.BoolOption(resolveRecursiveOptionName, "r", "Resolve until the result is an IPFS name.").WithDefault(true),
        cmds.IntOption(resolveDhtRecordCountOptionName, "dhtrc", "Number of records to request for DHT resolution."),
        cmds.StringOption(resolveDhtTimeoutOptionName, "dhtt", "Max time to collect values during DHT resolution eg \"30s\". Pass 0 for no timeout."),
    },
    Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
        api, err := cmdenv.GetApi(env, req)
        if err != nil {
            return err
        }

        name := req.Arguments[0]
        recursive, _ := req.Options[resolveRecursiveOptionName].(bool)

        var enc cidenc.Encoder
        switch {
        case !cmdenv.CidBaseDefined(req):

            enc, err = cmdenv.CidEncoderFromPath(name)
            if err == nil {
                break
            }

            fallthrough
        default:
            enc, err = cmdenv.GetCidEncoder(req)
            if err != nil {
                return err
            }
        }

        if strings.HasPrefix(name, "/ipns/") && !recursive {
            rc, rcok := req.Options[resolveDhtRecordCountOptionName].(uint)
            dhtt, dhttok := req.Options[resolveDhtTimeoutOptionName].(string)
            ropts := []options.NameResolveOption{
                options.Name.ResolveOption(nsopts.Depth(1)),
            }

            if rcok {
                ropts = append(ropts, options.Name.ResolveOption(nsopts.DhtRecordCount(rc)))
            }
            if dhttok {
                d, err := time.ParseDuration(dhtt)
                if err != nil {
                    return err
                }
                if d < 0 {
                    return errors.New("DHT timeout value must be >= 0")
                }
                ropts = append(ropts, options.Name.ResolveOption(nsopts.DhtTimeout(d)))
            }
            p, err := api.Name().Resolve(req.Context, name, ropts...)

            if err != nil && err != ns.ErrResolveRecursion {
                return err
            }
            return cmds.EmitOnce(res, &ncmd.ResolvedPath{Path: ipfspath.Path(p.String())})
        }

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

        encoded := "/" + rp.Namespace() + "/" + enc.Encode(rp.Cid())
        if remainder := rp.Remainder(); remainder != "" {
            encoded += "/" + remainder
        }

        return cmds.EmitOnce(res, &ncmd.ResolvedPath{Path: ipfspath.Path(encoded)})
    },
    Encoders: cmds.EncoderMap{
        cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, rp *ncmd.ResolvedPath) error {
            fmt.Fprintln(w, rp.Path.String())
            return nil
        }),
    },
    Type: ncmd.ResolvedPath{},
}
var Root = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:     "Global p2p merkle-dag filesystem.",
        Synopsis:    "" /* 202 byte string literal not displayed */,
        Subcommands: "" /* 2040 byte string literal not displayed */,
    },
    Options: []cmds.Option{
        cmds.StringOption(ConfigOption, "c", "Path to the configuration file to use."),
        cmds.BoolOption(DebugOption, "D", "Operate in debug mode."),
        cmds.BoolOption(cmds.OptLongHelp, "Show the full command help text."),
        cmds.BoolOption(cmds.OptShortHelp, "Show a short version of the command help text."),
        cmds.BoolOption(LocalOption, "L", "Run the command locally, instead of using the daemon. DEPRECATED: use --offline."),
        cmds.BoolOption(OfflineOption, "Run the command offline."),
        cmds.StringOption(ApiOption, "Use a specific API instance (defaults to /ip4/127.0.0.1/tcp/5001)"),

        cmdenv.OptionCidBase,
        cmdenv.OptionUpgradeCidV0InOutput,

        cmds.OptionEncodingType,
        cmds.OptionStreamChannels,
        cmds.OptionTimeout,
    },
}
var RootRO = &cmds.Command{}

RootRO is the readonly version of Root

var StatsCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline: "Query IPFS statistics.",
        ShortDescription: `'ipfs stats' is a set of commands to help look at statistics
for your IPFS node.
`,
        LongDescription: `'ipfs stats' is a set of commands to help look at statistics
for your IPFS node.`,
    },

    Subcommands: map[string]*cmds.Command{
        "bw":      statBwCmd,
        "repo":    repoStatCmd,
        "bitswap": bitswapStatCmd,
    },
}
var SwarmCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "Interact with the swarm.",
        ShortDescription: "" /* 174 byte string literal not displayed */,
    },
    Subcommands: map[string]*cmds.Command{
        "addrs":      swarmAddrsCmd,
        "connect":    swarmConnectCmd,
        "disconnect": swarmDisconnectCmd,
        "filters":    swarmFiltersCmd,
        "peers":      swarmPeersCmd,
    },
}
var TarCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline: "Utility functions for tar files in ipfs.",
    },

    Subcommands: map[string]*cmds.Command{
        "add": tarAddCmd,
        "cat": tarCatCmd,
    },
}
var VersionCmd = &cmds.Command{
    Helptext: cmds.HelpText{
        Tagline:          "Show ipfs version information.",
        ShortDescription: "Returns the current version of ipfs and exits.",
    },
    Subcommands: map[string]*cmds.Command{
        "deps": depsVersionCommand,
    },

    Options: []cmds.Option{
        cmds.BoolOption(versionNumberOptionName, "n", "Only show the version number."),
        cmds.BoolOption(versionCommitOptionName, "Show the commit hash."),
        cmds.BoolOption(versionRepoOptionName, "Show repo version."),
        cmds.BoolOption(versionAllOptionName, "Show all version information"),
    },
    Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
        return cmds.EmitOnce(res, &VersionOutput{
            Version: version.CurrentVersionNumber,
            Commit:  version.CurrentCommit,
            Repo:    fmt.Sprint(fsrepo.RepoVersion),
            System:  runtime.GOARCH + "/" + runtime.GOOS,
            Golang:  runtime.Version(),
        })
    },
    Encoders: cmds.EncoderMap{
        cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, version *VersionOutput) error {
            all, _ := req.Options[versionAllOptionName].(bool)
            if all {
                ver := version.Version
                if version.Commit != "" {
                    ver += "-" + version.Commit
                }
                out := fmt.Sprintf("go-ipfs version: %s\n"+
                    "Repo version: %s\nSystem version: %s\nGolang version: %s\n",
                    ver, version.Repo, version.System, version.Golang)
                fmt.Fprint(w, out)
                return nil
            }

            commit, _ := req.Options[versionCommitOptionName].(bool)
            commitTxt := ""
            if commit && version.Commit != "" {
                commitTxt = "-" + version.Commit
            }

            repo, _ := req.Options[versionRepoOptionName].(bool)
            if repo {
                fmt.Fprintln(w, version.Repo)
                return nil
            }

            number, _ := req.Options[versionNumberOptionName].(bool)
            if number {
                fmt.Fprintln(w, version.Version+commitTxt)
                return nil
            }

            fmt.Fprint(w, fmt.Sprintf("ipfs version %s%s\n", version.Version, commitTxt))
            return nil
        }),
    },
    Type: VersionOutput{},
}
var VersionROCmd = &cmds.Command{}

VersionROCmd is `ipfs version` command (without deps).

func CommandsCmd Uses

func CommandsCmd(root *cmds.Command) *cmds.Command

CommandsCmd takes in a root command, and returns a command that lists the subcommands in that root

func ExternalBinary Uses

func ExternalBinary(instructions string) *cmds.Command

func ParsePeerParam Uses

func ParsePeerParam(text string) (ma.Multiaddr, peer.ID, error)

type AddEvent Uses

type AddEvent struct {
    Name  string
    Hash  string `json:",omitempty"`
    Bytes int64  `json:",omitempty"`
    Size  string `json:",omitempty"`
}

type AddPinOutput Uses

type AddPinOutput struct {
    Pins     []string
    Progress int `json:",omitempty"`
}

type BadNode Uses

type BadNode struct {
    Cid string
    Err string
}

BadNode is used in PinVerifyRes

type BlockStat Uses

type BlockStat struct {
    Key  string
    Size int
}

func (BlockStat) String Uses

func (bs BlockStat) String() string

type BootstrapOutput Uses

type BootstrapOutput struct {
    Peers []string
}

type CidFormatRes Uses

type CidFormatRes struct {
    CidStr    string // Original Cid String passed in
    Formatted string // Formated Result
    ErrorMsg  string // Error
}

type CodeAndName Uses

type CodeAndName struct {
    Code int
    Name string
}

type Command Uses

type Command struct {
    Name        string
    Subcommands []Command
    Options     []Option
    // contains filtered or unexported fields
}

type ConfigField Uses

type ConfigField struct {
    Key   string
    Value interface{}
}

type ConfigUpdateOutput Uses

type ConfigUpdateOutput struct {
    OldCfg map[string]interface{}
    NewCfg map[string]interface{}
}

ConfigUpdateOutput is config profile apply command's output

type Dependency Uses

type Dependency struct {
    Path       string
    Version    string
    ReplacedBy string
    Sum        string
}

type GcResult Uses

type GcResult struct {
    Key   cid.Cid
    Error string `json:",omitempty"`
}

GcResult is the result returned by "repo gc" command.

type IdOutput Uses

type IdOutput struct {
    ID              string
    PublicKey       string
    Addresses       []string
    AgentVersion    string
    ProtocolVersion string
}

type KeyList Uses

type KeyList struct {
    Keys []cid.Cid
}

KeyList is a general type for outputting lists of keys

type KeyOutput Uses

type KeyOutput struct {
    Name string
    Id   string
}

type KeyOutputList Uses

type KeyOutputList struct {
    Keys []KeyOutput
}

type KeyRenameOutput Uses

type KeyRenameOutput struct {
    Was       string
    Now       string
    Id        string
    Overwrite bool
}

KeyRenameOutput define the output type of keyRenameCmd

type LsLink struct {
    Name, Hash string
    Size       uint64
    Type       unixfs_pb.Data_DataType
    Target     string
}

LsLink contains printable data for a single ipld link in ls output

type LsObject Uses

type LsObject struct {
    Hash  string
    Links []LsLink
}

LsObject is an element of LsOutput It can represent all or part of a directory

type LsOutput Uses

type LsOutput struct {
    Objects []LsObject
}

LsOutput is a set of printable data for directories, it can be complete or partial

type MessageOutput Uses

type MessageOutput struct {
    Message string
}

type Option Uses

type Option struct {
    Names []string
}

type P2PListenerInfoOutput Uses

type P2PListenerInfoOutput struct {
    Protocol      string
    ListenAddress string
    TargetAddress string
}

P2PListenerInfoOutput is output type of ls command

type P2PLsOutput Uses

type P2PLsOutput struct {
    Listeners []P2PListenerInfoOutput
}

P2PLsOutput is output type of ls command

type P2PStreamInfoOutput Uses

type P2PStreamInfoOutput struct {
    HandlerID     string
    Protocol      string
    OriginAddress string
    TargetAddress string
}

P2PStreamInfoOutput is output type of streams command

type P2PStreamsOutput Uses

type P2PStreamsOutput struct {
    Streams []P2PStreamInfoOutput
}

P2PStreamsOutput is output type of streams command

type PinLsList Uses

type PinLsList struct {
    Keys map[string]PinLsType
}

PinLsList is a set of pins with their type

type PinLsObject Uses

type PinLsObject struct {
    Cid  string `json:",omitempty"`
    Type string `json:",omitempty"`
}

PinLsObject contains the description of a pin

type PinLsOutputWrapper Uses

type PinLsOutputWrapper struct {
    PinLsList
    PinLsObject
}

PinLsOutputWrapper is the output type of the pin ls command. Pin ls needs to output two different type depending on if it's streamed or not. We use this to bypass the cmds lib refusing to have interface{}

type PinLsType Uses

type PinLsType struct {
    Type string
}

PinLsType contains the type of a pin

type PinOutput Uses

type PinOutput struct {
    Pins []string
}

type PinStatus Uses

type PinStatus struct {
    Ok       bool
    BadNodes []BadNode `json:",omitempty"`
}

PinStatus is part of PinVerifyRes, do not use directly

type PinVerifyRes Uses

type PinVerifyRes struct {
    Cid string
    PinStatus
}

PinVerifyRes is the result returned for each pin checked in "pin verify"

func (PinVerifyRes) Format Uses

func (r PinVerifyRes) Format(out io.Writer)

Format formats PinVerifyRes

type PingResult Uses

type PingResult struct {
    Success bool
    Time    time.Duration
    Text    string
}

type RefWrapper Uses

type RefWrapper struct {
    Ref string
    Err string
}

type RefWriter Uses

type RefWriter struct {
    DAG ipld.DAGService
    Ctx context.Context

    Unique   bool
    MaxDepth int
    PrintFmt string
    // contains filtered or unexported fields
}

func (*RefWriter) WriteEdge Uses

func (rw *RefWriter) WriteEdge(from, to cid.Cid, linkname string, enc cidenc.Encoder) error

Write one edge

func (*RefWriter) WriteRefs Uses

func (rw *RefWriter) WriteRefs(n ipld.Node, enc cidenc.Encoder) (int, error)

WriteRefs writes refs of the given object to the underlying writer.

type RepoVersion Uses

type RepoVersion struct {
    Version string
}

type VerifyProgress Uses

type VerifyProgress struct {
    Msg      string
    Progress int
}

type VersionOutput Uses

type VersionOutput struct {
    Version string
    Commit  string
    Repo    string
    System  string
    Golang  string
}

Directories

PathSynopsis
cmdenv
dag
e
name
object
unixfs

Package commands imports 95 packages (graph) and is imported by 65 packages. Updated 2019-12-08. Refresh now. Tools for package owners.