From 40a1c7575983bdf25651ab449933f5676f9ebc48 Mon Sep 17 00:00:00 2001 From: Overbool Date: Fri, 26 Oct 2018 15:52:19 +0800 Subject: [PATCH 1/3] refactor(cmds): use new cmds lib in version License: MIT Signed-off-by: Overbool --- core/commands/root.go | 4 +-- core/commands/version.go | 57 +++++++++++++--------------------------- 2 files changed, 20 insertions(+), 41 deletions(-) diff --git a/core/commands/root.go b/core/commands/root.go index ceb8436e2de..b9b2211b9e4 100644 --- a/core/commands/root.go +++ b/core/commands/root.go @@ -145,7 +145,7 @@ var rootSubcommands = map[string]*cmds.Command{ "file": lgc.NewCommand(unixfs.UnixFSCmd), "update": lgc.NewCommand(ExternalBinary()), "urlstore": urlStoreCmd, - "version": lgc.NewCommand(VersionCmd), + "version": VersionCmd, "shutdown": daemonShutdownCmd, "cid": CidCmd, } @@ -189,7 +189,7 @@ var rootROSubcommands = map[string]*cmds.Command{ }, }), "resolve": ResolveCmd, - "version": lgc.NewCommand(VersionCmd), + "version": VersionCmd, } func init() { diff --git a/core/commands/version.go b/core/commands/version.go index ebd8f5aba2a..5627adafae0 100644 --- a/core/commands/version.go +++ b/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/QmRRovo1DE6i5cMjCbf19mQCSuszF6SKwdZNUMS7MtBnH1/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{}, } From 9611d5f310789c90caef955bcb486aff3e4d6a83 Mon Sep 17 00:00:00 2001 From: Overbool Date: Fri, 26 Oct 2018 18:02:52 +0800 Subject: [PATCH 2/3] refactor(cmds): replace MakeEncoder with MakeTypedEncoder License: MIT Signed-off-by: Overbool --- core/commands/id.go | 20 +++++++------------- 1 file changed, 7 insertions(+), 13 deletions(-) diff --git a/core/commands/id.go b/core/commands/id.go index fdc02556087..f08af7d953f 100644 --- a/core/commands/id.go +++ b/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, "", val.ID, -1) - output = strings.Replace(output, "", val.AgentVersion, -1) - output = strings.Replace(output, "", val.ProtocolVersion, -1) - output = strings.Replace(output, "", val.PublicKey, -1) - output = strings.Replace(output, "", strings.Join(val.Addresses, "\n"), -1) + output = strings.Replace(output, "", out.ID, -1) + output = strings.Replace(output, "", out.AgentVersion, -1) + output = strings.Replace(output, "", out.ProtocolVersion, -1) + output = strings.Replace(output, "", out.PublicKey, -1) + output = strings.Replace(output, "", 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 } From 4160eaa63793b810faed3ea3cb0ba5ad8f4ad832 Mon Sep 17 00:00:00 2001 From: Overbool Date: Fri, 26 Oct 2018 20:51:30 +0800 Subject: [PATCH 3/3] refactor(cmds): use new cmds lib in tar, dns License: MIT Signed-off-by: Overbool --- core/commands/dns.go | 42 ++++++++-------------- core/commands/root.go | 6 ++-- core/commands/tar.go | 76 ++++++++++++++++------------------------ core/commands/version.go | 2 +- 4 files changed, 49 insertions(+), 77 deletions(-) diff --git a/core/commands/dns.go b/core/commands/dns.go index 9398ed0b7fb..8cef953e127 100644 --- a/core/commands/dns.go +++ b/core/commands/dns.go @@ -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{}, } diff --git a/core/commands/root.go b/core/commands/root.go index b9b2211b9e4..62fd57a4e84 100644 --- a/core/commands/root.go +++ b/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,7 +141,7 @@ 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, @@ -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{ diff --git a/core/commands/tar.go b/core/commands/tar.go index 86d7d79af06..a736a082781 100644 --- a/core/commands/tar.go +++ b/core/commands/tar.go @@ -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) }, } diff --git a/core/commands/version.go b/core/commands/version.go index 5627adafae0..d2c6df4bfbb 100644 --- a/core/commands/version.go +++ b/core/commands/version.go @@ -8,7 +8,7 @@ import ( version "github.com/ipfs/go-ipfs" fsrepo "github.com/ipfs/go-ipfs/repo/fsrepo" - cmds "gx/ipfs/QmRRovo1DE6i5cMjCbf19mQCSuszF6SKwdZNUMS7MtBnH1/go-ipfs-cmds" + cmds "gx/ipfs/QmdTmGruUz23vgzym3uWpnAEQdGdGifQqBvP8UXSRjG8gZ/go-ipfs-cmds" "gx/ipfs/Qmde5VP1qUkyQXKCfmEUA7bP64V2HAptbJ7phuPp7jXWwg/go-ipfs-cmdkit" )