refact(cmd/repo): repo verify uses new cmd lib

License: MIT
Signed-off-by: chenminjian <727180553@qq.com>

core/commands/repo.go

 package commands
 
 import (
-	"bytes"
 	"context"
 	"errors"
 	"fmt"
@@ -13,8 +12,6 @@ import (
 	"sync"
 	"text/tabwriter"
 
-	oldcmds "github.com/ipfs/go-ipfs/commands"
-	lgc "github.com/ipfs/go-ipfs/commands/legacy"
 	cmdenv "github.com/ipfs/go-ipfs/core/commands/cmdenv"
 	e "github.com/ipfs/go-ipfs/core/commands/e"
 	corerepo "github.com/ipfs/go-ipfs/core/corerepo"
@@ -44,7 +41,7 @@ var RepoCmd = &cmds.Command{
 		"gc":      repoGcCmd,
 		"fsck":    RepoFsckCmd,
 		"version": repoVersionCmd,
-		"verify":  lgc.NewCommand(repoVerifyCmd),
+		"verify":  repoVerifyCmd,
 	},
 }
 
@@ -323,91 +320,67 @@ func verifyResultChan(ctx context.Context, keys <-chan cid.Cid, bs bstore.Blocks
 	return results
 }
 
-var repoVerifyCmd = &oldcmds.Command{
+var repoVerifyCmd = &cmds.Command{
 	Helptext: cmdkit.HelpText{
 		Tagline: "Verify all blocks in repo are not corrupted.",
 	},
-	Run: func(req oldcmds.Request, res oldcmds.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
 		}
 
-		out := make(chan interface{})
-		res.SetOutput((<-chan interface{})(out))
-		defer close(out)
-
 		bs := bstore.NewBlockstore(nd.Repo.Datastore())
 		bs.HashOnRead(true)
 
-		keys, err := bs.AllKeysChan(req.Context())
+		keys, err := bs.AllKeysChan(req.Context)
 		if err != nil {
 			log.Error(err)
-			return
+			return err
 		}
 
-		results := verifyResultChan(req.Context(), keys, bs)
+		results := verifyResultChan(req.Context, keys, bs)
 
 		var fails int
 		var i int
 		for msg := range results {
 			if msg != "" {
-				select {
-				case out <- &VerifyProgress{Msg: msg}:
-				case <-req.Context().Done():
-					return
+				if err := res.Emit(&VerifyProgress{Msg: msg}); err != nil {
+					return err
 				}
 				fails++
 			}
 			i++
-			select {
-			case out <- &VerifyProgress{Progress: i}:
-			case <-req.Context().Done():
-				return
+			if err := res.Emit(&VerifyProgress{Progress: i}); err != nil {
+				return err
 			}
 		}
 
-		if fails == 0 {
-			select {
-			case out <- &VerifyProgress{Msg: "verify complete, all blocks validated."}:
-			case <-req.Context().Done():
-				return
-			}
-		} else {
-			res.SetError(fmt.Errorf("verify complete, some blocks were corrupt"), cmdkit.ErrNormal)
+		if fails != 0 {
+			return errors.New("verify complete, some blocks were corrupt")
 		}
+
+		return res.Emit(&VerifyProgress{Msg: "verify complete, all blocks validated."})
 	},
 	Type: &VerifyProgress{},
-	Marshalers: oldcmds.MarshalerMap{
-		oldcmds.Text: func(res oldcmds.Response) (io.Reader, error) {
-			v, err := unwrapOutput(res.Output())
-			if err != nil {
-				return nil, err
-			}
-
-			obj, ok := v.(*VerifyProgress)
-			if !ok {
-				return nil, e.TypeErr(obj, v)
-			}
-
-			buf := new(bytes.Buffer)
+	Encoders: cmds.EncoderMap{
+		cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, obj *VerifyProgress) error {
 			if strings.Contains(obj.Msg, "was corrupt") {
 				fmt.Fprintln(os.Stdout, obj.Msg)
-				return buf, nil
+				return nil
 			}
 
 			if obj.Msg != "" {
 				if len(obj.Msg) < 20 {
 					obj.Msg += "             "
 				}
-				fmt.Fprintln(buf, obj.Msg)
-				return buf, nil
+				fmt.Fprintln(w, obj.Msg)
+				return nil
 			}
 
-			fmt.Fprintf(buf, "%d blocks processed.\r", obj.Progress)
-			return buf, nil
-		},
+			fmt.Fprintf(w, "%d blocks processed.\r", obj.Progress)
+			return nil
+		}),
 	},
 }