swarm cmd: port to new cmd lib
License: MIT Signed-off-by: Łukasz Magiera <magik6k@gmail.com>
Łukasz Magiera committed
Sep 11, 2018 at 20:50 UTC
30d42f4550ec80c9d77f0d0cd1421f622fcffcce
5 files changed
+151
-207
core/commands/log.go
+22
@@ -1,10 +1,12 @@
1
package commands
2
3
import (
4
+ "bytes"
5
"fmt"
6
"io"
7
8
cmds "github.com/ipfs/go-ipfs/commands"
9
+ e "github.com/ipfs/go-ipfs/core/commands/e"
10
11
"gx/ipfs/QmSP88ryZkHSRn1fnngAaV2Vcn63WUJzAavnRM9CVdU1Ky/go-ipfs-cmdkit"
12
logging "gx/ipfs/QmZChCsSt8DctjceaL56Eibc29CVQq4dGKRXC5JRZ6Ppae/go-log"
@@ -110,3 +112,23 @@ Outputs event log messages (not other log messages) as they are generated.
112
res.SetOutput(r)
113
},
114
}
115
+
116
+func stringListMarshaler(res cmds.Response) (io.Reader, error) {
117
+ v, err := unwrapOutput(res.Output())
118
+ if err != nil {
119
+ return nil, err
120
+ }
121
+
122
+ list, ok := v.(*stringList)
123
+ if !ok {
124
+ return nil, e.TypeErr(list, v)
125
+ }
126
+
127
+ buf := new(bytes.Buffer)
128
+ for _, s := range list.Strings {
129
+ buf.WriteString(s)
130
+ buf.WriteString("\n")
131
+ }
132
+
133
+ return buf, nil
134
+}
core/commands/root.go
+1
-1
@@ -136,7 +136,7 @@ var rootSubcommands = map[string]*cmds.Command{
136
"p2p": lgc.NewCommand(P2PCmd),
137
"refs": lgc.NewCommand(RefsCmd),
138
"resolve": ResolveCmd,
139
- "swarm": lgc.NewCommand(SwarmCmd),
139
+ "swarm": SwarmCmd,
140
"tar": lgc.NewCommand(TarCmd),
141
"file": lgc.NewCommand(unixfs.UnixFSCmd),
142
"update": lgc.NewCommand(ExternalBinary()),
core/commands/swarm.go
+122
-200
@@ -1,7 +1,6 @@
1
package commands
2
3
import (
4
- "bytes"
4
"errors"
5
"fmt"
6
"io"
@@ -9,18 +8,20 @@ import (
8
"sort"
9
"strings"
10
12
- cmds "github.com/ipfs/go-ipfs/commands"
13
- e "github.com/ipfs/go-ipfs/core/commands/e"
14
- repo "github.com/ipfs/go-ipfs/repo"
11
+ "github.com/ipfs/go-ipfs/commands"
12
+ "github.com/ipfs/go-ipfs/core/commands/cmdenv"
13
+ "github.com/ipfs/go-ipfs/core/commands/e"
14
+ "github.com/ipfs/go-ipfs/repo"
15
"github.com/ipfs/go-ipfs/repo/fsrepo"
16
17
- swarm "gx/ipfs/QmPQoCVRHaGD25VffyB7DFV5qP65hFSQJdSDy75P1vYBKe/go-libp2p-swarm"
17
+ "gx/ipfs/QmPQoCVRHaGD25VffyB7DFV5qP65hFSQJdSDy75P1vYBKe/go-libp2p-swarm"
18
mafilter "gx/ipfs/QmSMZwvs3n4GBikZ7hKzT17c3bk65FmyZo2JqtJ16swqCv/multiaddr-filter"
19
- cmdkit "gx/ipfs/QmSP88ryZkHSRn1fnngAaV2Vcn63WUJzAavnRM9CVdU1Ky/go-ipfs-cmdkit"
19
+ "gx/ipfs/QmSP88ryZkHSRn1fnngAaV2Vcn63WUJzAavnRM9CVdU1Ky/go-ipfs-cmdkit"
20
iaddr "gx/ipfs/QmSzdvo9aPzLj4HXWTcgGAp8N84tZc8LbLmFZFwUb1dpWk/go-ipfs-addr"
21
- config "gx/ipfs/QmVBUpxsHh53rNcufqxMpLAmz37eGyLJUaexDy1W9YkiNk/go-ipfs-config"
21
+ "gx/ipfs/QmVBUpxsHh53rNcufqxMpLAmz37eGyLJUaexDy1W9YkiNk/go-ipfs-config"
22
+ "gx/ipfs/QmXTmUCBtDUrzDYVzASogLiNph7EBuYqEgPL7QoHNMzUnz/go-ipfs-cmds"
23
ma "gx/ipfs/QmYmsdtJ3HsodkePE3eU3TsCaP2YvPZJ4LoXnNkDE5Tpt7/go-multiaddr"
23
- peer "gx/ipfs/QmbNepETomvmXfz1X5pHNFD2QuPqnqi47dTd94QJWSorQ3/go-libp2p-peer"
24
+ "gx/ipfs/QmbNepETomvmXfz1X5pHNFD2QuPqnqi47dTd94QJWSorQ3/go-libp2p-peer"
25
pstore "gx/ipfs/QmfAQMFpgDU2U4BXG64qVr8HSiictfWvkSBz7Y2oDj65st/go-libp2p-peerstore"
26
inet "gx/ipfs/QmfDPh144WGBqRxZb1TGDHerbMnZATrHZggAPw7putNnBq/go-libp2p-net"
27
)
@@ -64,23 +65,20 @@ var swarmPeersCmd = &cmds.Command{
65
cmdkit.BoolOption("latency", "Also list information about latency to each peer"),
66
cmdkit.BoolOption("direction", "Also list information about the direction of connection"),
67
},
67
- Run: func(req cmds.Request, res cmds.Response) {
68
-
69
- n, err := req.InvocContext().GetNode()
68
+ Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
69
+ n, err := cmdenv.GetNode(env)
70
if err != nil {
71
- res.SetError(err, cmdkit.ErrNormal)
72
- return
71
+ return err
72
}
73
74
if n.PeerHost == nil {
76
- res.SetError(ErrNotOnline, cmdkit.ErrClient)
77
- return
75
+ return err
76
}
77
80
- verbose, _, _ := req.Option("verbose").Bool()
81
- latency, _, _ := req.Option("latency").Bool()
82
- streams, _, _ := req.Option("streams").Bool()
83
- direction, _, _ := req.Option("direction").Bool()
78
+ verbose, _ := req.Options["verbose"].(bool)
79
+ latency, _ := req.Options["latency"].(bool)
80
+ streams, _ := req.Options["streams"].(bool)
81
+ direction, _ := req.Options["direction"].(bool)
82
83
conns := n.PeerHost.Network().Conns()
84
var out connInfos
@@ -125,50 +123,43 @@ var swarmPeersCmd = &cmds.Command{
123
}
124
125
sort.Sort(&out)
128
- res.SetOutput(&out)
126
+ return cmds.EmitOnce(res, &out)
127
},
130
- Marshalers: cmds.MarshalerMap{
131
- cmds.Text: func(res cmds.Response) (io.Reader, error) {
132
- v, err := unwrapOutput(res.Output())
133
- if err != nil {
134
- return nil, err
135
- }
136
-
128
+ Encoders: cmds.EncoderMap{
129
+ cmds.Text: cmds.MakeEncoder(func(req *cmds.Request, w io.Writer, v interface{}) error {
130
ci, ok := v.(*connInfos)
131
if !ok {
139
- return nil, e.TypeErr(ci, v)
132
+ return e.TypeErr(ci, v)
133
}
134
142
- buf := new(bytes.Buffer)
135
pipfs := ma.ProtocolWithCode(ma.P_IPFS).Name
136
for _, info := range ci.Peers {
137
ids := fmt.Sprintf("/%s/%s", pipfs, info.Peer)
138
if strings.HasSuffix(info.Addr, ids) {
147
- fmt.Fprintf(buf, "%s", info.Addr)
139
+ fmt.Fprintf(w, "%s", info.Addr)
140
} else {
149
- fmt.Fprintf(buf, "%s%s", info.Addr, ids)
141
+ fmt.Fprintf(w, "%s%s", info.Addr, ids)
142
}
143
if info.Latency != "" {
152
- fmt.Fprintf(buf, " %s", info.Latency)
144
+ fmt.Fprintf(w, " %s", info.Latency)
145
}
146
147
if info.Direction != inet.DirUnknown {
156
- fmt.Fprintf(buf, " %s", directionString(info.Direction))
148
+ fmt.Fprintf(w, " %s", directionString(info.Direction))
149
}
158
-
159
- fmt.Fprintln(buf)
150
+ fmt.Fprintln(w)
151
152
for _, s := range info.Streams {
153
if s.Protocol == "" {
154
s.Protocol = "<no protocol name>"
155
}
156
166
- fmt.Fprintf(buf, " %s\n", s.Protocol)
157
+ fmt.Fprintf(w, " %s\n", s.Protocol)
158
}
159
}
160
170
- return buf, nil
171
- },
161
+ return nil
162
+ }),
163
},
164
Type: connInfos{},
165
}
@@ -237,17 +228,14 @@ var swarmAddrsCmd = &cmds.Command{
228
"local": swarmAddrsLocalCmd,
229
"listen": swarmAddrsListenCmd,
230
},
240
- Run: func(req cmds.Request, res cmds.Response) {
241
-
242
- n, err := req.InvocContext().GetNode()
231
+ Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
232
+ n, err := cmdenv.GetNode(env)
233
if err != nil {
244
- res.SetError(err, cmdkit.ErrNormal)
245
- return
234
+ return err
235
}
236
237
if n.PeerHost == nil {
249
- res.SetError(ErrNotOnline, cmdkit.ErrClient)
250
- return
238
+ return err
239
}
240
241
addrs := make(map[string][]string)
@@ -260,18 +248,13 @@ var swarmAddrsCmd = &cmds.Command{
248
sort.Sort(sort.StringSlice(addrs[s]))
249
}
250
263
- res.SetOutput(&addrMap{Addrs: addrs})
251
+ return cmds.EmitOnce(res, &addrMap{Addrs: addrs})
252
},
265
- Marshalers: cmds.MarshalerMap{
266
- cmds.Text: func(res cmds.Response) (io.Reader, error) {
267
- v, err := unwrapOutput(res.Output())
268
- if err != nil {
269
- return nil, err
270
- }
271
-
253
+ Encoders: cmds.EncoderMap{
254
+ cmds.Text: cmds.MakeEncoder(func(req *cmds.Request, w io.Writer, v interface{}) error {
255
m, ok := v.(*addrMap)
256
if !ok {
274
- return nil, e.TypeErr(m, v)
257
+ return e.TypeErr(m, v)
258
}
259
260
// sort the ids first
@@ -281,16 +264,15 @@ var swarmAddrsCmd = &cmds.Command{
264
}
265
sort.Sort(sort.StringSlice(ids))
266
284
- buf := new(bytes.Buffer)
267
for _, p := range ids {
268
paddrs := m.Addrs[p]
287
- buf.WriteString(fmt.Sprintf("%s (%d)\n", p, len(paddrs)))
269
+ fmt.Fprintf(w, "%s (%d)\n", p, len(paddrs))
270
for _, addr := range paddrs {
289
- buf.WriteString("\t" + addr + "\n")
271
+ fmt.Fprintf(w, "\t"+addr+"\n")
272
}
273
}
292
- return buf, nil
293
- },
274
+ return nil
275
+ }),
276
},
277
Type: addrMap{},
278
}
@@ -305,20 +287,17 @@ var swarmAddrsLocalCmd = &cmds.Command{
287
Options: []cmdkit.Option{
288
cmdkit.BoolOption("id", "Show peer ID in addresses."),
289
},
308
- Run: func(req cmds.Request, res cmds.Response) {
309
- iCtx := req.InvocContext()
310
- n, err := iCtx.GetNode()
290
+ Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
291
+ n, err := cmdenv.GetNode(env)
292
if err != nil {
312
- res.SetError(err, cmdkit.ErrNormal)
313
- return
293
+ return err
294
}
295
296
if n.PeerHost == nil {
317
- res.SetError(ErrNotOnline, cmdkit.ErrClient)
318
- return
297
+ return err
298
}
299
321
- showid, _, _ := req.Option("id").Bool()
300
+ showid, _ := req.Options["id"].(bool)
301
id := n.Identity.Pretty()
302
303
var addrs []string
@@ -330,11 +309,11 @@ var swarmAddrsLocalCmd = &cmds.Command{
309
addrs = append(addrs, saddr)
310
}
311
sort.Sort(sort.StringSlice(addrs))
333
- res.SetOutput(&stringList{addrs})
312
+ return cmds.EmitOnce(res, &stringList{addrs})
313
},
314
Type: stringList{},
336
- Marshalers: cmds.MarshalerMap{
337
- cmds.Text: stringListMarshaler,
315
+ Encoders: cmds.EncoderMap{
316
+ cmds.Text: cmds.MakeEncoder(stringListEncoder),
317
},
318
}
319
@@ -345,24 +324,20 @@ var swarmAddrsListenCmd = &cmds.Command{
324
'ipfs swarm addrs listen' lists all interface addresses the node is listening on.
325
`,
326
},
348
- Run: func(req cmds.Request, res cmds.Response) {
349
-
350
- n, err := req.InvocContext().GetNode()
327
+ Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
328
+ n, err := cmdenv.GetNode(env)
329
if err != nil {
352
- res.SetError(err, cmdkit.ErrNormal)
353
- return
330
+ return err
331
}
332
333
if n.PeerHost == nil {
357
- res.SetError(ErrNotOnline, cmdkit.ErrClient)
358
- return
334
+ return err
335
}
336
337
var addrs []string
338
maddrs, err := n.PeerHost.Network().InterfaceListenAddresses()
339
if err != nil {
364
- res.SetError(err, cmdkit.ErrNormal)
365
- return
340
+ return err
341
}
342
343
for _, addr := range maddrs {
@@ -370,11 +345,11 @@ var swarmAddrsListenCmd = &cmds.Command{
345
}
346
sort.Sort(sort.StringSlice(addrs))
347
373
- res.SetOutput(&stringList{addrs})
348
+ return cmds.EmitOnce(res, &stringList{addrs})
349
},
350
Type: stringList{},
376
- Marshalers: cmds.MarshalerMap{
377
- cmds.Text: stringListMarshaler,
351
+ Encoders: cmds.EncoderMap{
352
+ cmds.Text: cmds.MakeEncoder(stringListEncoder),
353
},
354
}
355
@@ -392,33 +367,27 @@ ipfs swarm connect /ip4/104.131.131.82/tcp/4001/ipfs/QmaCpDMGvV2BGHeYERUEnRQAwe3
367
Arguments: []cmdkit.Argument{
368
cmdkit.StringArg("address", true, true, "Address of peer to connect to.").EnableStdin(),
369
},
395
- Run: func(req cmds.Request, res cmds.Response) {
396
- ctx := req.Context()
397
-
398
- n, err := req.InvocContext().GetNode()
370
+ Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
371
+ n, err := cmdenv.GetNode(env)
372
if err != nil {
400
- res.SetError(err, cmdkit.ErrNormal)
401
- return
373
+ return err
374
}
375
404
- addrs := req.Arguments()
376
+ addrs := req.Arguments
377
378
if n.PeerHost == nil {
407
- res.SetError(ErrNotOnline, cmdkit.ErrClient)
408
- return
379
+ return err
380
}
381
382
// FIXME(steb): Nasty
383
swrm, ok := n.PeerHost.Network().(*swarm.Swarm)
384
if !ok {
414
- res.SetError(fmt.Errorf("peerhost network was not swarm"), cmdkit.ErrNormal)
415
- return
385
+ return fmt.Errorf("peerhost network was not swarm")
386
}
387
388
pis, err := peersWithAddresses(addrs)
389
if err != nil {
420
- res.SetError(err, cmdkit.ErrNormal)
421
- return
390
+ return err
391
}
392
393
output := make([]string, len(pis))
@@ -427,18 +396,17 @@ ipfs swarm connect /ip4/104.131.131.82/tcp/4001/ipfs/QmaCpDMGvV2BGHeYERUEnRQAwe3
396
397
output[i] = "connect " + pi.ID.Pretty()
398
430
- err := n.PeerHost.Connect(ctx, pi)
399
+ err := n.PeerHost.Connect(req.Context, pi)
400
if err != nil {
432
- res.SetError(fmt.Errorf("%s failure: %s", output[i], err), cmdkit.ErrNormal)
433
- return
401
+ return fmt.Errorf("%s failure: %s", output[i], err)
402
}
403
output[i] += " success"
404
}
405
438
- res.SetOutput(&stringList{output})
406
+ return cmds.EmitOnce(res, &stringList{addrs})
407
},
440
- Marshalers: cmds.MarshalerMap{
441
- cmds.Text: stringListMarshaler,
408
+ Encoders: cmds.EncoderMap{
409
+ cmds.Text: cmds.MakeEncoder(stringListEncoder),
410
},
411
Type: stringList{},
412
}
@@ -459,24 +427,21 @@ it will reconnect.
427
Arguments: []cmdkit.Argument{
428
cmdkit.StringArg("address", true, true, "Address of peer to disconnect from.").EnableStdin(),
429
},
462
- Run: func(req cmds.Request, res cmds.Response) {
463
- n, err := req.InvocContext().GetNode()
430
+ Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
431
+ n, err := cmdenv.GetNode(env)
432
if err != nil {
465
- res.SetError(err, cmdkit.ErrNormal)
466
- return
433
+ return err
434
}
435
469
- addrs := req.Arguments()
436
+ addrs := req.Arguments
437
438
if n.PeerHost == nil {
472
- res.SetError(ErrNotOnline, cmdkit.ErrClient)
473
- return
439
+ return ErrNotOnline
440
}
441
442
iaddrs, err := parseAddresses(addrs)
443
if err != nil {
478
- res.SetError(err, cmdkit.ErrNormal)
479
- return
444
+ return err
445
}
446
447
output := make([]string, len(iaddrs))
@@ -516,34 +481,14 @@ it will reconnect.
481
}
482
}
483
}
519
- res.SetOutput(&stringList{output})
484
+ return cmds.EmitOnce(res, &stringList{output})
485
},
521
- Marshalers: cmds.MarshalerMap{
522
- cmds.Text: stringListMarshaler,
486
+ Encoders: cmds.EncoderMap{
487
+ cmds.Text: cmds.MakeEncoder(stringListEncoder),
488
},
489
Type: stringList{},
490
}
491
527
-func stringListMarshaler(res cmds.Response) (io.Reader, error) {
528
- v, err := unwrapOutput(res.Output())
529
- if err != nil {
530
- return nil, err
531
- }
532
-
533
- list, ok := v.(*stringList)
534
- if !ok {
535
- return nil, e.TypeErr(list, v)
536
- }
537
-
538
- buf := new(bytes.Buffer)
539
- for _, s := range list.Strings {
540
- buf.WriteString(s)
541
- buf.WriteString("\n")
542
- }
543
-
544
- return buf, nil
545
-}
546
-
492
// parseAddresses is a function that takes in a slice of string peer addresses
493
// (multiaddr + peerid) and returns slices of multiaddrs and peerids.
494
func parseAddresses(addrs []string) (iaddrs []iaddr.IPFSAddr, err error) {
@@ -608,38 +553,34 @@ Filters default to those specified under the "Swarm.AddrFilters" config key.
553
"add": swarmFiltersAddCmd,
554
"rm": swarmFiltersRmCmd,
555
},
611
- Run: func(req cmds.Request, res cmds.Response) {
612
- n, err := req.InvocContext().GetNode()
556
+ Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
557
+ n, err := cmdenv.GetNode(env)
558
if err != nil {
614
- res.SetError(err, cmdkit.ErrNormal)
615
- return
559
+ return err
560
}
561
562
if n.PeerHost == nil {
619
- res.SetError(ErrNotOnline, cmdkit.ErrNormal)
620
- return
563
+ return ErrNotOnline
564
}
565
566
// FIXME(steb)
567
swrm, ok := n.PeerHost.Network().(*swarm.Swarm)
568
if !ok {
626
- res.SetError(errors.New("failed to cast network to swarm network"), cmdkit.ErrNormal)
627
- return
569
+ return errors.New("failed to cast network to swarm network")
570
}
571
572
var output []string
573
for _, f := range swrm.Filters.Filters() {
574
s, err := mafilter.ConvertIPNet(f)
575
if err != nil {
634
- res.SetError(err, cmdkit.ErrNormal)
635
- return
576
+ return err
577
}
578
output = append(output, s)
579
}
639
- res.SetOutput(&stringList{output})
580
+ return cmds.EmitOnce(res, &stringList{output})
581
},
641
- Marshalers: cmds.MarshalerMap{
642
- cmds.Text: stringListMarshaler,
582
+ Encoders: cmds.EncoderMap{
583
+ cmds.Text: cmds.MakeEncoder(stringListEncoder),
584
},
585
Type: stringList{},
586
}
@@ -656,63 +597,54 @@ add your filters to the ipfs config file.
597
Arguments: []cmdkit.Argument{
598
cmdkit.StringArg("address", true, true, "Multiaddr to filter.").EnableStdin(),
599
},
659
- Run: func(req cmds.Request, res cmds.Response) {
660
- n, err := req.InvocContext().GetNode()
600
+ Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
601
+ n, err := cmdenv.GetNode(env)
602
if err != nil {
662
- res.SetError(err, cmdkit.ErrNormal)
663
- return
603
+ return err
604
}
605
606
if n.PeerHost == nil {
667
- res.SetError(ErrNotOnline, cmdkit.ErrNormal)
668
- return
607
+ return ErrNotOnline
608
}
609
610
// FIXME(steb)
611
swrm, ok := n.PeerHost.Network().(*swarm.Swarm)
612
if !ok {
674
- res.SetError(errors.New("failed to cast network to swarm network"), cmdkit.ErrNormal)
675
- return
613
+ return errors.New("failed to cast network to swarm network")
614
}
615
678
- if len(req.Arguments()) == 0 {
679
- res.SetError(errors.New("no filters to add"), cmdkit.ErrClient)
680
- return
616
+ if len(req.Arguments) == 0 {
617
+ return errors.New("no filters to add")
618
}
619
683
- r, err := fsrepo.Open(req.InvocContext().ConfigRoot)
620
+ r, err := fsrepo.Open(env.(*commands.Context).ConfigRoot)
621
if err != nil {
685
- res.SetError(err, cmdkit.ErrNormal)
686
- return
622
+ return err
623
}
624
defer r.Close()
625
cfg, err := r.Config()
626
if err != nil {
691
- res.SetError(err, cmdkit.ErrNormal)
692
- return
627
+ return err
628
}
629
695
- for _, arg := range req.Arguments() {
630
+ for _, arg := range req.Arguments {
631
mask, err := mafilter.NewMask(arg)
632
if err != nil {
698
- res.SetError(err, cmdkit.ErrNormal)
699
- return
633
+ return err
634
}
635
636
swrm.Filters.AddDialFilter(mask)
637
}
638
705
- added, err := filtersAdd(r, cfg, req.Arguments())
639
+ added, err := filtersAdd(r, cfg, req.Arguments)
640
if err != nil {
707
- res.SetError(err, cmdkit.ErrNormal)
708
- return
709
-
641
+ return err
642
}
643
712
- res.SetOutput(&stringList{added})
644
+ return cmds.EmitOnce(res, &stringList{added})
645
},
714
- Marshalers: cmds.MarshalerMap{
715
- cmds.Text: stringListMarshaler,
646
+ Encoders: cmds.EncoderMap{
647
+ cmds.Text: cmds.MakeEncoder(stringListEncoder),
648
},
649
Type: stringList{},
650
}
@@ -729,37 +661,32 @@ remove your filters from the ipfs config file.
661
Arguments: []cmdkit.Argument{
662
cmdkit.StringArg("address", true, true, "Multiaddr filter to remove.").EnableStdin(),
663
},
732
- Run: func(req cmds.Request, res cmds.Response) {
733
- n, err := req.InvocContext().GetNode()
664
+ Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
665
+ n, err := cmdenv.GetNode(env)
666
if err != nil {
735
- res.SetError(err, cmdkit.ErrNormal)
736
- return
667
+ return err
668
}
669
670
if n.PeerHost == nil {
740
- res.SetError(ErrNotOnline, cmdkit.ErrNormal)
741
- return
671
+ return ErrNotOnline
672
}
673
674
swrm, ok := n.PeerHost.Network().(*swarm.Swarm)
675
if !ok {
746
- res.SetError(errors.New("failed to cast network to swarm network"), cmdkit.ErrNormal)
747
- return
676
+ return errors.New("failed to cast network to swarm network")
677
}
678
750
- r, err := fsrepo.Open(req.InvocContext().ConfigRoot)
679
+ r, err := fsrepo.Open(env.(*commands.Context).ConfigRoot)
680
if err != nil {
752
- res.SetError(err, cmdkit.ErrNormal)
753
- return
681
+ return err
682
}
683
defer r.Close()
684
cfg, err := r.Config()
685
if err != nil {
758
- res.SetError(err, cmdkit.ErrNormal)
759
- return
686
+ return err
687
}
688
762
- if req.Arguments()[0] == "all" || req.Arguments()[0] == "*" {
689
+ if req.Arguments[0] == "all" || req.Arguments[0] == "*" {
690
fs := swrm.Filters.Filters()
691
for _, f := range fs {
692
swrm.Filters.Remove(f)
@@ -767,35 +694,30 @@ remove your filters from the ipfs config file.
694
695
removed, err := filtersRemoveAll(r, cfg)
696
if err != nil {
770
- res.SetError(err, cmdkit.ErrNormal)
771
- return
697
+ return err
698
}
699
774
- res.SetOutput(&stringList{removed})
775
-
776
- return
700
+ return cmds.EmitOnce(res, &stringList{removed})
701
}
702
779
- for _, arg := range req.Arguments() {
703
+ for _, arg := range req.Arguments {
704
mask, err := mafilter.NewMask(arg)
705
if err != nil {
782
- res.SetError(err, cmdkit.ErrNormal)
783
- return
706
+ return err
707
}
708
709
swrm.Filters.Remove(mask)
710
}
711
789
- removed, err := filtersRemove(r, cfg, req.Arguments())
712
+ removed, err := filtersRemove(r, cfg, req.Arguments)
713
if err != nil {
791
- res.SetError(err, cmdkit.ErrNormal)
792
- return
714
+ return err
715
}
716
795
- res.SetOutput(&stringList{removed})
717
+ return cmds.EmitOnce(res, &stringList{removed})
718
},
797
- Marshalers: cmds.MarshalerMap{
798
- cmds.Text: stringListMarshaler,
719
+ Encoders: cmds.EncoderMap{
720
+ cmds.Text: cmds.MakeEncoder(stringListEncoder),
721
},
722
Type: stringList{},
723
}
core/coreapi/interface/swarm.go
+1
-1
@@ -4,8 +4,8 @@ import (
4
"context"
5
"time"
6
7
- peer "gx/ipfs/QmQsErDt8Qgw1XrsXf2BpEzDgGWtB1YLsTAARBup5b6B9W/go-libp2p-peer"
7
ma "gx/ipfs/QmYmsdtJ3HsodkePE3eU3TsCaP2YvPZJ4LoXnNkDE5Tpt7/go-multiaddr"
8
+ peer "gx/ipfs/QmbNepETomvmXfz1X5pHNFD2QuPqnqi47dTd94QJWSorQ3/go-libp2p-peer"
9
)
10
11
// PeerInfo contains information about a peer
core/coreapi/swarm.go
+5
-5
@@ -8,12 +8,12 @@ import (
8
9
coreiface "github.com/ipfs/go-ipfs/core/coreapi/interface"
10
11
- peer "gx/ipfs/QmQsErDt8Qgw1XrsXf2BpEzDgGWtB1YLsTAARBup5b6B9W/go-libp2p-peer"
11
+ swarm "gx/ipfs/QmPQoCVRHaGD25VffyB7DFV5qP65hFSQJdSDy75P1vYBKe/go-libp2p-swarm"
12
+ iaddr "gx/ipfs/QmSzdvo9aPzLj4HXWTcgGAp8N84tZc8LbLmFZFwUb1dpWk/go-ipfs-addr"
13
ma "gx/ipfs/QmYmsdtJ3HsodkePE3eU3TsCaP2YvPZJ4LoXnNkDE5Tpt7/go-multiaddr"
13
- net "gx/ipfs/QmZNJyx9GGCX4GeuHnLB8fxaxMLs4MjTjHokxfQcCd6Nve/go-libp2p-net"
14
- pstore "gx/ipfs/Qmda4cPRvSRyox3SqgJN6DfSZGU5TtHufPTp9uXjFj71X6/go-libp2p-peerstore"
15
- swarm "gx/ipfs/QmeDpqUwwdye8ABKVMPXKuWwPVURFdqTqssbTUB39E2Nwd/go-libp2p-swarm"
16
- iaddr "gx/ipfs/QmePSRaGafvmURQwQkHPDBJsaGwKXC1WpBBHVCQxdr8FPn/go-ipfs-addr"
14
+ peer "gx/ipfs/QmbNepETomvmXfz1X5pHNFD2QuPqnqi47dTd94QJWSorQ3/go-libp2p-peer"
15
+ pstore "gx/ipfs/QmfAQMFpgDU2U4BXG64qVr8HSiictfWvkSBz7Y2oDj65st/go-libp2p-peerstore"
16
+ net "gx/ipfs/QmfDPh144WGBqRxZb1TGDHerbMnZATrHZggAPw7putNnBq/go-libp2p-net"
17
)
18
19
type SwarmAPI struct {