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

refactor(cmds): use new cmds lib in version, tar and dns

core/commands/dns.go

 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
-		}
-		if err != nil {
-			res.SetError(err, cmdkit.ErrNormal)
-			return
+			return err
 		}
-		res.SetOutput(&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 err
 		}
-			return strings.NewReader(output.Path.String() + "\n"), nil
+		return res.Emit(&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{},
 }

core/commands/id.go

@@ -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
 				}

core/commands/root.go

@@ -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() {

core/commands/tar.go

 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)
 	},
 }

core/commands/version.go

@@ -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{},
 }