coosld/kubo
1
0
Fork 0
mirror of https://github.com/ipfs/kubo.git synced 2026-02-25 04:17:44 +08:00
Code Issues Actions 14 Packages Projects Releases Wiki Activity

Merge pull request #5650 from overbool/refactor/new-cmds-lib

Browse Source 
refactor(cmds): use new cmds lib in version, tar and dns
This commit is contained in:
Steven Allen 2018-10-26 11:21:22 -07:00 committed by GitHub
commit 3accb7bebd
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
5 changed files with 75 additions and 130 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
core/commands/dns.go
View File

@ -1,16 +1,15 @@
package commands
import (
"fmt"
"io"
"strings"
cmds "github.com/ipfs/go-ipfs/commands"
e "github.com/ipfs/go-ipfs/core/commands/e"
ncmd "github.com/ipfs/go-ipfs/core/commands/name"
namesys "github.com/ipfs/go-ipfs/namesys"
nsopts "github.com/ipfs/go-ipfs/namesys/opts"
"gx/ipfs/Qmde5VP1qUkyQXKCfmEUA7bP64V2HAptbJ7phuPp7jXWwg/go-ipfs-cmdkit"
cmds "gx/ipfs/QmdTmGruUz23vgzym3uWpnAEQdGdGifQqBvP8UXSRjG8gZ/go-ipfs-cmds"
cmdkit "gx/ipfs/Qmde5VP1qUkyQXKCfmEUA7bP64V2HAptbJ7phuPp7jXWwg/go-ipfs-cmdkit"
)
const (
@ -61,10 +60,9 @@ The resolver can recursively resolve:
Options: []cmdkit.Option{
cmdkit.BoolOption(dnsRecursiveOptionName, "r", "Resolve until the result is not a DNS link."),
},
Run: func(req cmds.Request, res cmds.Response) {
recursive, _, _ := req.Option(dnsRecursiveOptionName).Bool()
name := req.Arguments()[0]
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 ropts []nsopts.ResolveOpt
@ -72,30 +70,20 @@ The resolver can recursively resolve:
ropts = append(ropts, nsopts.Depth(1))
}
output, err := resolver.Resolve(req.Context(), name, ropts...)
output, err := resolver.Resolve(req.Context, name, ropts...)
if err == namesys.ErrResolveFailed {
res.SetError(err, cmdkit.ErrNotFound)
return
return err
}
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
res.SetOutput(&ncmd.ResolvedPath{Path: output})
return res.Emit(&ncmd.ResolvedPath{Path: output})
},
Marshalers: cmds.MarshalerMap{
cmds.Text: func(res cmds.Response) (io.Reader, error) {
v, err := unwrapOutput(res.Output())
if err != nil {
return nil, err
}
output, ok := v.(*ncmd.ResolvedPath)
if !ok {
return nil, e.TypeErr(output, v)
}
return strings.NewReader(output.Path.String() + "\n"), nil
},
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{},
}

20
core/commands/id.go
View File

@ -10,7 +10,6 @@ import (
core "github.com/ipfs/go-ipfs/core"
cmdenv "github.com/ipfs/go-ipfs/core/commands/cmdenv"
e "github.com/ipfs/go-ipfs/core/commands/e"
ic "gx/ipfs/QmPvyPwuCgJ7pDmrKDxRtsScJgBaM5h4EpRL2qQJsmXf4n/go-libp2p-crypto"
"gx/ipfs/QmTRhk7cgjUf2gfQ3p2M9KPECNZEW9XUrmHcFCgog4cPgB/go-libp2p-peer"
@ -112,25 +111,20 @@ EXAMPLE:
return cmds.EmitOnce(res, output)
},
Encoders: cmds.EncoderMap{
cmds.Text: cmds.MakeEncoder(func(req *cmds.Request, w io.Writer, v interface{}) error {
val, ok := v.(*IdOutput)
if !ok {
return e.TypeErr(val, v)
}
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>", val.ID, -1)
output = strings.Replace(output, "<aver>", val.AgentVersion, -1)
output = strings.Replace(output, "<pver>", val.ProtocolVersion, -1)
output = strings.Replace(output, "<pubkey>", val.PublicKey, -1)
output = strings.Replace(output, "<addrs>", strings.Join(val.Addresses, "\n"), -1)
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(val, "", "\t")
marshaled, err := json.MarshalIndent(out, "", "\t")
if err != nil {
return err
}

10
core/commands/root.go
View File

@ -127,7 +127,7 @@ var rootSubcommands = map[string]*cmds.Command{
"dag": lgc.NewCommand(dag.DagCmd),
"dht": lgc.NewCommand(DhtCmd),
"diag": lgc.NewCommand(DiagCmd),
"dns": lgc.NewCommand(DNSCmd),
"dns": DNSCmd,
"id": IDCmd,
"key": KeyCmd,
"log": lgc.NewCommand(LogCmd),
@ -141,11 +141,11 @@ var rootSubcommands = map[string]*cmds.Command{
"refs": lgc.NewCommand(RefsCmd),
"resolve": ResolveCmd,
"swarm": SwarmCmd,
"tar": lgc.NewCommand(TarCmd),
"tar": TarCmd,
"file": lgc.NewCommand(unixfs.UnixFSCmd),
"update": lgc.NewCommand(ExternalBinary()),
"urlstore": urlStoreCmd,
"version": lgc.NewCommand(VersionCmd),
"version": VersionCmd,
"shutdown": daemonShutdownCmd,
"cid": CidCmd,
}
@ -167,7 +167,7 @@ var rootROSubcommands = map[string]*cmds.Command{
},
},
"get": GetCmd,
"dns": lgc.NewCommand(DNSCmd),
"dns": DNSCmd,
"ls": lgc.NewCommand(LsCmd),
"name": &cmds.Command{
Subcommands: map[string]*cmds.Command{
@ -189,7 +189,7 @@ var rootROSubcommands = map[string]*cmds.Command{
},
}),
"resolve": ResolveCmd,
"version": lgc.NewCommand(VersionCmd),
"version": VersionCmd,
}
func init() {

76
core/commands/tar.go
View File

@ -1,18 +1,18 @@
package commands
import (
"fmt"
"io"
"strings"
cmds "github.com/ipfs/go-ipfs/commands"
core "github.com/ipfs/go-ipfs/core"
e "github.com/ipfs/go-ipfs/core/commands/e"
cmdenv "github.com/ipfs/go-ipfs/core/commands/cmdenv"
coreiface "github.com/ipfs/go-ipfs/core/coreapi/interface"
tar "github.com/ipfs/go-ipfs/tar"
path "gx/ipfs/QmRKuTyCzg7HFBcV1YUhzStroGtJSb8iWgyxfsDCwFhWTS/go-path"
dag "gx/ipfs/QmY8BMUSpCwNiTmFhACmC9Bt1qT63cHP35AoQAus4x14qH/go-merkledag"
"gx/ipfs/Qmde5VP1qUkyQXKCfmEUA7bP64V2HAptbJ7phuPp7jXWwg/go-ipfs-cmdkit"
"gx/ipfs/QmRKuTyCzg7HFBcV1YUhzStroGtJSb8iWgyxfsDCwFhWTS/go-path"
dag "gx/ipfs/QmY8BMUSpCwNiTmFhACmC9Bt1qT63cHP35AoQAus4x14qH/go-merkledag"
cmds "gx/ipfs/QmdTmGruUz23vgzym3uWpnAEQdGdGifQqBvP8UXSRjG8gZ/go-ipfs-cmds"
cmdkit "gx/ipfs/Qmde5VP1qUkyQXKCfmEUA7bP64V2HAptbJ7phuPp7jXWwg/go-ipfs-cmdkit"
)
var TarCmd = &cmds.Command{
@ -38,47 +38,36 @@ represent it.
Arguments: []cmdkit.Argument{
cmdkit.FileArg("file", true, false, "Tar file to add.").EnableStdin(),
},
Run: func(req cmds.Request, res cmds.Response) {
nd, err := req.InvocContext().GetNode()
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
nd, err := cmdenv.GetNode(env)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
fi, err := req.Files().NextFile()
fi, err := req.Files.NextFile()
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
node, err := tar.ImportTar(req.Context(), fi, nd.DAG)
node, err := tar.ImportTar(req.Context, fi, nd.DAG)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
c := node.Cid()
fi.FileName()
res.SetOutput(&coreiface.AddEvent{
return res.Emit(&coreiface.AddEvent{
Name: fi.FileName(),
Hash: c.String(),
})
},
Type: coreiface.AddEvent{},
Marshalers: cmds.MarshalerMap{
cmds.Text: func(res cmds.Response) (io.Reader, error) {
v, err := unwrapOutput(res.Output())
if err != nil {
return nil, err
}
o, ok := v.(*coreiface.AddEvent)
if !ok {
return nil, e.TypeErr(o, v)
}
return strings.NewReader(o.Hash + "\n"), nil
},
Encoders: cmds.EncoderMap{
cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, out *coreiface.AddEvent) error {
fmt.Fprintln(w, out.Hash)
return nil
}),
},
}
@ -93,37 +82,32 @@ var tarCatCmd = &cmds.Command{
Arguments: []cmdkit.Argument{
cmdkit.StringArg("path", true, false, "ipfs path of archive to export.").EnableStdin(),
},
Run: func(req cmds.Request, res cmds.Response) {
nd, err := req.InvocContext().GetNode()
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
nd, err := cmdenv.GetNode(env)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
p, err := path.ParsePath(req.Arguments()[0])
p, err := path.ParsePath(req.Arguments[0])
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
root, err := core.Resolve(req.Context(), nd.Namesys, nd.Resolver, p)
root, err := core.Resolve(req.Context, nd.Namesys, nd.Resolver, p)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
rootpb, ok := root.(*dag.ProtoNode)
if !ok {
res.SetError(dag.ErrNotProtobuf, cmdkit.ErrNormal)
return
return dag.ErrNotProtobuf
}
r, err := tar.ExportTar(req.Context(), rootpb, nd.DAG)
r, err := tar.ExportTar(req.Context, rootpb, nd.DAG)
if err != nil {
res.SetError(err, cmdkit.ErrNormal)
return
return err
}
res.SetOutput(r)
return res.Emit(r)
},
}

57
core/commands/version.go
View File

@ -4,13 +4,11 @@ import (
"fmt"
"io"
"runtime"
"strings"
version "github.com/ipfs/go-ipfs"
cmds "github.com/ipfs/go-ipfs/commands"
e "github.com/ipfs/go-ipfs/core/commands/e"
fsrepo "github.com/ipfs/go-ipfs/repo/fsrepo"
cmds "gx/ipfs/QmdTmGruUz23vgzym3uWpnAEQdGdGifQqBvP8UXSRjG8gZ/go-ipfs-cmds"
"gx/ipfs/Qmde5VP1qUkyQXKCfmEUA7bP64V2HAptbJ7phuPp7jXWwg/go-ipfs-cmdkit"
)
@ -41,8 +39,8 @@ var VersionCmd = &cmds.Command{
cmdkit.BoolOption(versionRepoOptionName, "Show repo version."),
cmdkit.BoolOption(versionAllOptionName, "Show all version information"),
},
Run: func(req cmds.Request, res cmds.Response) {
res.SetOutput(&VersionOutput{
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
return res.Emit(&VersionOutput{
Version: version.CurrentVersionNumber,
Commit: version.CurrentCommit,
Repo: fmt.Sprint(fsrepo.RepoVersion),
@ -50,57 +48,38 @@ var VersionCmd = &cmds.Command{
Golang: runtime.Version(),
})
},
Marshalers: cmds.MarshalerMap{
cmds.Text: func(res cmds.Response) (io.Reader, error) {
v, err := unwrapOutput(res.Output())
if err != nil {
return nil, err
}
version, ok := v.(*VersionOutput)
if !ok {
return nil, e.TypeErr(version, v)
}
repo, _, err := res.Request().Option(versionRepoOptionName).Bool()
if err != nil {
return nil, err
}
Encoders: cmds.EncoderMap{
cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, version *VersionOutput) error {
repo, _ := req.Options[versionRepoOptionName].(bool)
if repo {
return strings.NewReader(version.Repo + "\n"), nil
fmt.Fprintln(w, version.Repo)
return nil
}
commit, _, err := res.Request().Option(versionCommitOptionName).Bool()
commit, _ := req.Options[versionCommitOptionName].(bool)
commitTxt := ""
if err != nil {
return nil, err
}
if commit {
commitTxt = "-" + version.Commit
}
number, _, err := res.Request().Option(versionNumberOptionName).Bool()
if err != nil {
return nil, err
}
number, _ := req.Options[versionNumberOptionName].(bool)
if number {
return strings.NewReader(fmt.Sprintln(version.Version + commitTxt)), nil
fmt.Fprintln(w, version.Version+commitTxt)
return nil
}
all, _, err := res.Request().Option(versionAllOptionName).Bool()
if err != nil {
return nil, err
}
all, _ := req.Options[versionAllOptionName].(bool)
if all {
out := fmt.Sprintf("go-ipfs version: %s-%s\n"+
"Repo version: %s\nSystem version: %s\nGolang version: %s\n",
version.Version, version.Commit, version.Repo, version.System, version.Golang)
return strings.NewReader(out), nil
fmt.Fprint(w, out)
return nil
}
return strings.NewReader(fmt.Sprintf("ipfs version %s%s\n", version.Version, commitTxt)), nil
},
fmt.Fprint(w, fmt.Sprintf("ipfs version %s%s\n", version.Version, commitTxt))
return nil
}),
},
Type: VersionOutput{},
}