swarm cmd: port to new cmd lib

License: MIT
Signed-off-by: Łukasz Magiera <magik6k@gmail.com>

core/commands/log.go

 package commands
 
 import (
+	"bytes"
 	"fmt"
 	"io"
 
 	cmds "github.com/ipfs/go-ipfs/commands"
+	e "github.com/ipfs/go-ipfs/core/commands/e"
 
 	"gx/ipfs/QmSP88ryZkHSRn1fnngAaV2Vcn63WUJzAavnRM9CVdU1Ky/go-ipfs-cmdkit"
 	logging "gx/ipfs/QmZChCsSt8DctjceaL56Eibc29CVQq4dGKRXC5JRZ6Ppae/go-log"
@@ -110,3 +112,23 @@ Outputs event log messages (not other log messages) as they are generated.
 		res.SetOutput(r)
 	},
 }
+
+func stringListMarshaler(res cmds.Response) (io.Reader, error) {
+	v, err := unwrapOutput(res.Output())
+	if err != nil {
+		return nil, err
+	}
+
+	list, ok := v.(*stringList)
+	if !ok {
+		return nil, e.TypeErr(list, v)
+	}
+
+	buf := new(bytes.Buffer)
+	for _, s := range list.Strings {
+		buf.WriteString(s)
+		buf.WriteString("\n")
+	}
+
+	return buf, nil
+}

core/commands/root.go

@@ -136,7 +136,7 @@ var rootSubcommands = map[string]*cmds.Command{
 	"p2p":       lgc.NewCommand(P2PCmd),
 	"refs":      lgc.NewCommand(RefsCmd),
 	"resolve":   ResolveCmd,
-	"swarm":     lgc.NewCommand(SwarmCmd),
+	"swarm":     SwarmCmd,
 	"tar":       lgc.NewCommand(TarCmd),
 	"file":      lgc.NewCommand(unixfs.UnixFSCmd),
 	"update":    lgc.NewCommand(ExternalBinary()),

core/commands/swarm.go

 package commands
 
 import (
-	"bytes"
 	"errors"
 	"fmt"
 	"io"
@@ -9,18 +8,20 @@ import (
 	"sort"
 	"strings"
 
-	cmds "github.com/ipfs/go-ipfs/commands"
-	e "github.com/ipfs/go-ipfs/core/commands/e"
-	repo "github.com/ipfs/go-ipfs/repo"
+	"github.com/ipfs/go-ipfs/commands"
+	"github.com/ipfs/go-ipfs/core/commands/cmdenv"
+	"github.com/ipfs/go-ipfs/core/commands/e"
+	"github.com/ipfs/go-ipfs/repo"
 	"github.com/ipfs/go-ipfs/repo/fsrepo"
 
-	swarm "gx/ipfs/QmPQoCVRHaGD25VffyB7DFV5qP65hFSQJdSDy75P1vYBKe/go-libp2p-swarm"
+	"gx/ipfs/QmPQoCVRHaGD25VffyB7DFV5qP65hFSQJdSDy75P1vYBKe/go-libp2p-swarm"
 	mafilter "gx/ipfs/QmSMZwvs3n4GBikZ7hKzT17c3bk65FmyZo2JqtJ16swqCv/multiaddr-filter"
-	cmdkit "gx/ipfs/QmSP88ryZkHSRn1fnngAaV2Vcn63WUJzAavnRM9CVdU1Ky/go-ipfs-cmdkit"
+	"gx/ipfs/QmSP88ryZkHSRn1fnngAaV2Vcn63WUJzAavnRM9CVdU1Ky/go-ipfs-cmdkit"
 	iaddr "gx/ipfs/QmSzdvo9aPzLj4HXWTcgGAp8N84tZc8LbLmFZFwUb1dpWk/go-ipfs-addr"
-	config "gx/ipfs/QmVBUpxsHh53rNcufqxMpLAmz37eGyLJUaexDy1W9YkiNk/go-ipfs-config"
+	"gx/ipfs/QmVBUpxsHh53rNcufqxMpLAmz37eGyLJUaexDy1W9YkiNk/go-ipfs-config"
+	"gx/ipfs/QmXTmUCBtDUrzDYVzASogLiNph7EBuYqEgPL7QoHNMzUnz/go-ipfs-cmds"
 	ma "gx/ipfs/QmYmsdtJ3HsodkePE3eU3TsCaP2YvPZJ4LoXnNkDE5Tpt7/go-multiaddr"
-	peer "gx/ipfs/QmbNepETomvmXfz1X5pHNFD2QuPqnqi47dTd94QJWSorQ3/go-libp2p-peer"
+	"gx/ipfs/QmbNepETomvmXfz1X5pHNFD2QuPqnqi47dTd94QJWSorQ3/go-libp2p-peer"
 	pstore "gx/ipfs/QmfAQMFpgDU2U4BXG64qVr8HSiictfWvkSBz7Y2oDj65st/go-libp2p-peerstore"
 	inet "gx/ipfs/QmfDPh144WGBqRxZb1TGDHerbMnZATrHZggAPw7putNnBq/go-libp2p-net"
 )
@@ -64,23 +65,20 @@ var swarmPeersCmd = &cmds.Command{
 		cmdkit.BoolOption("latency", "Also list information about latency to each peer"),
 		cmdkit.BoolOption("direction", "Also list information about the direction of connection"),
 	},
-	Run: func(req cmds.Request, res cmds.Response) {
-
-		n, err := req.InvocContext().GetNode()
+	Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
+		n, err := cmdenv.GetNode(env)
 		if err != nil {
-			res.SetError(err, cmdkit.ErrNormal)
-			return
+			return err
 		}
 
 		if n.PeerHost == nil {
-			res.SetError(ErrNotOnline, cmdkit.ErrClient)
-			return
+			return err
 		}
 
-		verbose, _, _ := req.Option("verbose").Bool()
-		latency, _, _ := req.Option("latency").Bool()
-		streams, _, _ := req.Option("streams").Bool()
-		direction, _, _ := req.Option("direction").Bool()
+		verbose, _ := req.Options["verbose"].(bool)
+		latency, _ := req.Options["latency"].(bool)
+		streams, _ := req.Options["streams"].(bool)
+		direction, _ := req.Options["direction"].(bool)
 
 		conns := n.PeerHost.Network().Conns()
 		var out connInfos
@@ -125,50 +123,43 @@ var swarmPeersCmd = &cmds.Command{
 		}
 
 		sort.Sort(&out)
-		res.SetOutput(&out)
+		return cmds.EmitOnce(res, &out)
 	},
-	Marshalers: cmds.MarshalerMap{
-		cmds.Text: func(res cmds.Response) (io.Reader, error) {
-			v, err := unwrapOutput(res.Output())
-			if err != nil {
-				return nil, err
-			}
-
+	Encoders: cmds.EncoderMap{
+		cmds.Text: cmds.MakeEncoder(func(req *cmds.Request, w io.Writer, v interface{}) error {
 			ci, ok := v.(*connInfos)
 			if !ok {
-				return nil, e.TypeErr(ci, v)
+				return e.TypeErr(ci, v)
 			}
 
-			buf := new(bytes.Buffer)
 			pipfs := ma.ProtocolWithCode(ma.P_IPFS).Name
 			for _, info := range ci.Peers {
 				ids := fmt.Sprintf("/%s/%s", pipfs, info.Peer)
 				if strings.HasSuffix(info.Addr, ids) {
-					fmt.Fprintf(buf, "%s", info.Addr)
+					fmt.Fprintf(w, "%s", info.Addr)
 				} else {
-					fmt.Fprintf(buf, "%s%s", info.Addr, ids)
+					fmt.Fprintf(w, "%s%s", info.Addr, ids)
 				}
 				if info.Latency != "" {
-					fmt.Fprintf(buf, " %s", info.Latency)
+					fmt.Fprintf(w, " %s", info.Latency)
 				}
 
 				if info.Direction != inet.DirUnknown {
-					fmt.Fprintf(buf, " %s", directionString(info.Direction))
+					fmt.Fprintf(w, " %s", directionString(info.Direction))
 				}
-
-				fmt.Fprintln(buf)
+				fmt.Fprintln(w)
 
 				for _, s := range info.Streams {
 					if s.Protocol == "" {
 						s.Protocol = "<no protocol name>"
 					}
 
-					fmt.Fprintf(buf, "  %s\n", s.Protocol)
+					fmt.Fprintf(w, "  %s\n", s.Protocol)
 				}
 			}
 
-			return buf, nil
-		},
+			return nil
+		}),
 	},
 	Type: connInfos{},
 }
@@ -237,17 +228,14 @@ var swarmAddrsCmd = &cmds.Command{
 		"local":  swarmAddrsLocalCmd,
 		"listen": swarmAddrsListenCmd,
 	},
-	Run: func(req cmds.Request, res cmds.Response) {
-
-		n, err := req.InvocContext().GetNode()
+	Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
+		n, err := cmdenv.GetNode(env)
 		if err != nil {
-			res.SetError(err, cmdkit.ErrNormal)
-			return
+			return err
 		}
 
 		if n.PeerHost == nil {
-			res.SetError(ErrNotOnline, cmdkit.ErrClient)
-			return
+			return err
 		}
 
 		addrs := make(map[string][]string)
@@ -260,18 +248,13 @@ var swarmAddrsCmd = &cmds.Command{
 			sort.Sort(sort.StringSlice(addrs[s]))
 		}
 
-		res.SetOutput(&addrMap{Addrs: addrs})
+		return cmds.EmitOnce(res, &addrMap{Addrs: addrs})
 	},
-	Marshalers: cmds.MarshalerMap{
-		cmds.Text: func(res cmds.Response) (io.Reader, error) {
-			v, err := unwrapOutput(res.Output())
-			if err != nil {
-				return nil, err
-			}
-
+	Encoders: cmds.EncoderMap{
+		cmds.Text: cmds.MakeEncoder(func(req *cmds.Request, w io.Writer, v interface{}) error {
 			m, ok := v.(*addrMap)
 			if !ok {
-				return nil, e.TypeErr(m, v)
+				return e.TypeErr(m, v)
 			}
 
 			// sort the ids first
@@ -281,16 +264,15 @@ var swarmAddrsCmd = &cmds.Command{
 			}
 			sort.Sort(sort.StringSlice(ids))
 
-			buf := new(bytes.Buffer)
 			for _, p := range ids {
 				paddrs := m.Addrs[p]
-				buf.WriteString(fmt.Sprintf("%s (%d)\n", p, len(paddrs)))
+				fmt.Fprintf(w, "%s (%d)\n", p, len(paddrs))
 				for _, addr := range paddrs {
-					buf.WriteString("\t" + addr + "\n")
+					fmt.Fprintf(w, "\t"+addr+"\n")
 				}
 			}
-			return buf, nil
-		},
+			return nil
+		}),
 	},
 	Type: addrMap{},
 }
@@ -305,20 +287,17 @@ var swarmAddrsLocalCmd = &cmds.Command{
 	Options: []cmdkit.Option{
 		cmdkit.BoolOption("id", "Show peer ID in addresses."),
 	},
-	Run: func(req cmds.Request, res cmds.Response) {
-		iCtx := req.InvocContext()
-		n, err := iCtx.GetNode()
+	Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
+		n, err := cmdenv.GetNode(env)
 		if err != nil {
-			res.SetError(err, cmdkit.ErrNormal)
-			return
+			return err
 		}
 
 		if n.PeerHost == nil {
-			res.SetError(ErrNotOnline, cmdkit.ErrClient)
-			return
+			return err
 		}
 
-		showid, _, _ := req.Option("id").Bool()
+		showid, _ := req.Options["id"].(bool)
 		id := n.Identity.Pretty()
 
 		var addrs []string
@@ -330,11 +309,11 @@ var swarmAddrsLocalCmd = &cmds.Command{
 			addrs = append(addrs, saddr)
 		}
 		sort.Sort(sort.StringSlice(addrs))
-		res.SetOutput(&stringList{addrs})
+		return cmds.EmitOnce(res, &stringList{addrs})
 	},
 	Type: stringList{},
-	Marshalers: cmds.MarshalerMap{
-		cmds.Text: stringListMarshaler,
+	Encoders: cmds.EncoderMap{
+		cmds.Text: cmds.MakeEncoder(stringListEncoder),
 	},
 }
 
@@ -345,24 +324,20 @@ var swarmAddrsListenCmd = &cmds.Command{
 'ipfs swarm addrs listen' lists all interface addresses the node is listening on.
 `,
 	},
-	Run: func(req cmds.Request, res cmds.Response) {
-
-		n, err := req.InvocContext().GetNode()
+	Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
+		n, err := cmdenv.GetNode(env)
 		if err != nil {
-			res.SetError(err, cmdkit.ErrNormal)
-			return
+			return err
 		}
 
 		if n.PeerHost == nil {
-			res.SetError(ErrNotOnline, cmdkit.ErrClient)
-			return
+			return err
 		}
 
 		var addrs []string
 		maddrs, err := n.PeerHost.Network().InterfaceListenAddresses()
 		if err != nil {
-			res.SetError(err, cmdkit.ErrNormal)
-			return
+			return err
 		}
 
 		for _, addr := range maddrs {
@@ -370,11 +345,11 @@ var swarmAddrsListenCmd = &cmds.Command{
 		}
 		sort.Sort(sort.StringSlice(addrs))
 
-		res.SetOutput(&stringList{addrs})
+		return cmds.EmitOnce(res, &stringList{addrs})
 	},
 	Type: stringList{},
-	Marshalers: cmds.MarshalerMap{
-		cmds.Text: stringListMarshaler,
+	Encoders: cmds.EncoderMap{
+		cmds.Text: cmds.MakeEncoder(stringListEncoder),
 	},
 }
 
@@ -392,33 +367,27 @@ ipfs swarm connect /ip4/104.131.131.82/tcp/4001/ipfs/QmaCpDMGvV2BGHeYERUEnRQAwe3
 	Arguments: []cmdkit.Argument{
 		cmdkit.StringArg("address", true, true, "Address of peer to connect to.").EnableStdin(),
 	},
-	Run: func(req cmds.Request, res cmds.Response) {
-		ctx := req.Context()
-
-		n, err := req.InvocContext().GetNode()
+	Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
+		n, err := cmdenv.GetNode(env)
 		if err != nil {
-			res.SetError(err, cmdkit.ErrNormal)
-			return
+			return err
 		}
 
-		addrs := req.Arguments()
+		addrs := req.Arguments
 
 		if n.PeerHost == nil {
-			res.SetError(ErrNotOnline, cmdkit.ErrClient)
-			return
+			return err
 		}
 
 		// FIXME(steb): Nasty
 		swrm, ok := n.PeerHost.Network().(*swarm.Swarm)
 		if !ok {
-			res.SetError(fmt.Errorf("peerhost network was not swarm"), cmdkit.ErrNormal)
-			return
+			return fmt.Errorf("peerhost network was not swarm")
 		}
 
 		pis, err := peersWithAddresses(addrs)
 		if err != nil {
-			res.SetError(err, cmdkit.ErrNormal)
-			return
+			return err
 		}
 
 		output := make([]string, len(pis))
@@ -427,18 +396,17 @@ ipfs swarm connect /ip4/104.131.131.82/tcp/4001/ipfs/QmaCpDMGvV2BGHeYERUEnRQAwe3
 
 			output[i] = "connect " + pi.ID.Pretty()
 
-			err := n.PeerHost.Connect(ctx, pi)
+			err := n.PeerHost.Connect(req.Context, pi)
 			if err != nil {
-				res.SetError(fmt.Errorf("%s failure: %s", output[i], err), cmdkit.ErrNormal)
-				return
+				return fmt.Errorf("%s failure: %s", output[i], err)
 			}
 			output[i] += " success"
 		}
 
-		res.SetOutput(&stringList{output})
+		return cmds.EmitOnce(res, &stringList{addrs})
 	},
-	Marshalers: cmds.MarshalerMap{
-		cmds.Text: stringListMarshaler,
+	Encoders: cmds.EncoderMap{
+		cmds.Text: cmds.MakeEncoder(stringListEncoder),
 	},
 	Type: stringList{},
 }
@@ -459,24 +427,21 @@ it will reconnect.
 	Arguments: []cmdkit.Argument{
 		cmdkit.StringArg("address", true, true, "Address of peer to disconnect from.").EnableStdin(),
 	},
-	Run: func(req cmds.Request, res cmds.Response) {
-		n, err := req.InvocContext().GetNode()
+	Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
+		n, err := cmdenv.GetNode(env)
 		if err != nil {
-			res.SetError(err, cmdkit.ErrNormal)
-			return
+			return err
 		}
 
-		addrs := req.Arguments()
+		addrs := req.Arguments
 
 		if n.PeerHost == nil {
-			res.SetError(ErrNotOnline, cmdkit.ErrClient)
-			return
+			return ErrNotOnline
 		}
 
 		iaddrs, err := parseAddresses(addrs)
 		if err != nil {
-			res.SetError(err, cmdkit.ErrNormal)
-			return
+			return err
 		}
 
 		output := make([]string, len(iaddrs))
@@ -516,34 +481,14 @@ it will reconnect.
 				}
 			}
 		}
-		res.SetOutput(&stringList{output})
+		return cmds.EmitOnce(res, &stringList{output})
 	},
-	Marshalers: cmds.MarshalerMap{
-		cmds.Text: stringListMarshaler,
+	Encoders: cmds.EncoderMap{
+		cmds.Text: cmds.MakeEncoder(stringListEncoder),
 	},
 	Type: stringList{},
 }
 
-func stringListMarshaler(res cmds.Response) (io.Reader, error) {
-	v, err := unwrapOutput(res.Output())
-	if err != nil {
-		return nil, err
-	}
-
-	list, ok := v.(*stringList)
-	if !ok {
-		return nil, e.TypeErr(list, v)
-	}
-
-	buf := new(bytes.Buffer)
-	for _, s := range list.Strings {
-		buf.WriteString(s)
-		buf.WriteString("\n")
-	}
-
-	return buf, nil
-}
-
 // parseAddresses is a function that takes in a slice of string peer addresses
 // (multiaddr + peerid) and returns slices of multiaddrs and peerids.
 func parseAddresses(addrs []string) (iaddrs []iaddr.IPFSAddr, err error) {
@@ -608,38 +553,34 @@ Filters default to those specified under the "Swarm.AddrFilters" config key.
 		"add": swarmFiltersAddCmd,
 		"rm":  swarmFiltersRmCmd,
 	},
-	Run: func(req cmds.Request, res cmds.Response) {
-		n, err := req.InvocContext().GetNode()
+	Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
+		n, err := cmdenv.GetNode(env)
 		if err != nil {
-			res.SetError(err, cmdkit.ErrNormal)
-			return
+			return err
 		}
 
 		if n.PeerHost == nil {
-			res.SetError(ErrNotOnline, cmdkit.ErrNormal)
-			return
+			return ErrNotOnline
 		}
 
 		// FIXME(steb)
 		swrm, ok := n.PeerHost.Network().(*swarm.Swarm)
 		if !ok {
-			res.SetError(errors.New("failed to cast network to swarm network"), cmdkit.ErrNormal)
-			return
+			return errors.New("failed to cast network to swarm network")
 		}
 
 		var output []string
 		for _, f := range swrm.Filters.Filters() {
 			s, err := mafilter.ConvertIPNet(f)
 			if err != nil {
-				res.SetError(err, cmdkit.ErrNormal)
-				return
+				return err
 			}
 			output = append(output, s)
 		}
-		res.SetOutput(&stringList{output})
+		return cmds.EmitOnce(res, &stringList{output})
 	},
-	Marshalers: cmds.MarshalerMap{
-		cmds.Text: stringListMarshaler,
+	Encoders: cmds.EncoderMap{
+		cmds.Text: cmds.MakeEncoder(stringListEncoder),
 	},
 	Type: stringList{},
 }
@@ -656,63 +597,54 @@ add your filters to the ipfs config file.
 	Arguments: []cmdkit.Argument{
 		cmdkit.StringArg("address", true, true, "Multiaddr to filter.").EnableStdin(),
 	},
-	Run: func(req cmds.Request, res cmds.Response) {
-		n, err := req.InvocContext().GetNode()
+	Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
+		n, err := cmdenv.GetNode(env)
 		if err != nil {
-			res.SetError(err, cmdkit.ErrNormal)
-			return
+			return err
 		}
 
 		if n.PeerHost == nil {
-			res.SetError(ErrNotOnline, cmdkit.ErrNormal)
-			return
+			return ErrNotOnline
 		}
 
 		// FIXME(steb)
 		swrm, ok := n.PeerHost.Network().(*swarm.Swarm)
 		if !ok {
-			res.SetError(errors.New("failed to cast network to swarm network"), cmdkit.ErrNormal)
-			return
+			return errors.New("failed to cast network to swarm network")
 		}
 
-		if len(req.Arguments()) == 0 {
-			res.SetError(errors.New("no filters to add"), cmdkit.ErrClient)
-			return
+		if len(req.Arguments) == 0 {
+			return errors.New("no filters to add")
 		}
 
-		r, err := fsrepo.Open(req.InvocContext().ConfigRoot)
+		r, err := fsrepo.Open(env.(*commands.Context).ConfigRoot)
 		if err != nil {
-			res.SetError(err, cmdkit.ErrNormal)
-			return
+			return err
 		}
 		defer r.Close()
 		cfg, err := r.Config()
 		if err != nil {
-			res.SetError(err, cmdkit.ErrNormal)
-			return
+			return err
 		}
 
-		for _, arg := range req.Arguments() {
+		for _, arg := range req.Arguments {
 			mask, err := mafilter.NewMask(arg)
 			if err != nil {
-				res.SetError(err, cmdkit.ErrNormal)
-				return
+				return err
 			}
 
 			swrm.Filters.AddDialFilter(mask)
 		}
 
-		added, err := filtersAdd(r, cfg, req.Arguments())
+		added, err := filtersAdd(r, cfg, req.Arguments)
 		if err != nil {
-			res.SetError(err, cmdkit.ErrNormal)
-			return
-
+			return err
 		}
 
-		res.SetOutput(&stringList{added})
+		return cmds.EmitOnce(res, &stringList{added})
 	},
-	Marshalers: cmds.MarshalerMap{
-		cmds.Text: stringListMarshaler,
+	Encoders: cmds.EncoderMap{
+		cmds.Text: cmds.MakeEncoder(stringListEncoder),
 	},
 	Type: stringList{},
 }
@@ -729,37 +661,32 @@ remove your filters from the ipfs config file.
 	Arguments: []cmdkit.Argument{
 		cmdkit.StringArg("address", true, true, "Multiaddr filter to remove.").EnableStdin(),
 	},
-	Run: func(req cmds.Request, res cmds.Response) {
-		n, err := req.InvocContext().GetNode()
+	Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
+		n, err := cmdenv.GetNode(env)
 		if err != nil {
-			res.SetError(err, cmdkit.ErrNormal)
-			return
+			return err
 		}
 
 		if n.PeerHost == nil {
-			res.SetError(ErrNotOnline, cmdkit.ErrNormal)
-			return
+			return ErrNotOnline
 		}
 
 		swrm, ok := n.PeerHost.Network().(*swarm.Swarm)
 		if !ok {
-			res.SetError(errors.New("failed to cast network to swarm network"), cmdkit.ErrNormal)
-			return
+			return errors.New("failed to cast network to swarm network")
 		}
 
-		r, err := fsrepo.Open(req.InvocContext().ConfigRoot)
+		r, err := fsrepo.Open(env.(*commands.Context).ConfigRoot)
 		if err != nil {
-			res.SetError(err, cmdkit.ErrNormal)
-			return
+			return err
 		}
 		defer r.Close()
 		cfg, err := r.Config()
 		if err != nil {
-			res.SetError(err, cmdkit.ErrNormal)
-			return
+			return err
 		}
 
-		if req.Arguments()[0] == "all" || req.Arguments()[0] == "*" {
+		if req.Arguments[0] == "all" || req.Arguments[0] == "*" {
 			fs := swrm.Filters.Filters()
 			for _, f := range fs {
 				swrm.Filters.Remove(f)
@@ -767,35 +694,30 @@ remove your filters from the ipfs config file.
 
 			removed, err := filtersRemoveAll(r, cfg)
 			if err != nil {
-				res.SetError(err, cmdkit.ErrNormal)
-				return
+				return err
 			}
 
-			res.SetOutput(&stringList{removed})
-
-			return
+			return cmds.EmitOnce(res, &stringList{removed})
 		}
 
-		for _, arg := range req.Arguments() {
+		for _, arg := range req.Arguments {
 			mask, err := mafilter.NewMask(arg)
 			if err != nil {
-				res.SetError(err, cmdkit.ErrNormal)
-				return
+				return err
 			}
 
 			swrm.Filters.Remove(mask)
 		}
 
-		removed, err := filtersRemove(r, cfg, req.Arguments())
+		removed, err := filtersRemove(r, cfg, req.Arguments)
 		if err != nil {
-			res.SetError(err, cmdkit.ErrNormal)
-			return
+			return err
 		}
 
-		res.SetOutput(&stringList{removed})
+		return cmds.EmitOnce(res, &stringList{removed})
 	},
-	Marshalers: cmds.MarshalerMap{
-		cmds.Text: stringListMarshaler,
+	Encoders: cmds.EncoderMap{
+		cmds.Text: cmds.MakeEncoder(stringListEncoder),
 	},
 	Type: stringList{},
 }

core/coreapi/interface/swarm.go

@@ -4,8 +4,8 @@ import (
 	"context"
 	"time"
 
-	peer "gx/ipfs/QmQsErDt8Qgw1XrsXf2BpEzDgGWtB1YLsTAARBup5b6B9W/go-libp2p-peer"
 	ma "gx/ipfs/QmYmsdtJ3HsodkePE3eU3TsCaP2YvPZJ4LoXnNkDE5Tpt7/go-multiaddr"
+	peer "gx/ipfs/QmbNepETomvmXfz1X5pHNFD2QuPqnqi47dTd94QJWSorQ3/go-libp2p-peer"
 )
 
 // PeerInfo contains information about a peer

core/coreapi/swarm.go

@@ -8,12 +8,12 @@ import (
 
 	coreiface "github.com/ipfs/go-ipfs/core/coreapi/interface"
 
-	peer "gx/ipfs/QmQsErDt8Qgw1XrsXf2BpEzDgGWtB1YLsTAARBup5b6B9W/go-libp2p-peer"
+	swarm "gx/ipfs/QmPQoCVRHaGD25VffyB7DFV5qP65hFSQJdSDy75P1vYBKe/go-libp2p-swarm"
+	iaddr "gx/ipfs/QmSzdvo9aPzLj4HXWTcgGAp8N84tZc8LbLmFZFwUb1dpWk/go-ipfs-addr"
 	ma "gx/ipfs/QmYmsdtJ3HsodkePE3eU3TsCaP2YvPZJ4LoXnNkDE5Tpt7/go-multiaddr"
-	net "gx/ipfs/QmZNJyx9GGCX4GeuHnLB8fxaxMLs4MjTjHokxfQcCd6Nve/go-libp2p-net"
-	pstore "gx/ipfs/Qmda4cPRvSRyox3SqgJN6DfSZGU5TtHufPTp9uXjFj71X6/go-libp2p-peerstore"
-	swarm "gx/ipfs/QmeDpqUwwdye8ABKVMPXKuWwPVURFdqTqssbTUB39E2Nwd/go-libp2p-swarm"
-	iaddr "gx/ipfs/QmePSRaGafvmURQwQkHPDBJsaGwKXC1WpBBHVCQxdr8FPn/go-ipfs-addr"
+	peer "gx/ipfs/QmbNepETomvmXfz1X5pHNFD2QuPqnqi47dTd94QJWSorQ3/go-libp2p-peer"
+	pstore "gx/ipfs/QmfAQMFpgDU2U4BXG64qVr8HSiictfWvkSBz7Y2oDj65st/go-libp2p-peerstore"
+	net "gx/ipfs/QmfDPh144WGBqRxZb1TGDHerbMnZATrHZggAPw7putNnBq/go-libp2p-net"
 )
 
 type SwarmAPI struct {