coosld/kubo
1
0
Fork 0
mirror of https://github.com/ipfs/kubo.git synced 2026-03-03 15:27:57 +08:00
Code Issues Actions 4 Packages Projects Releases Wiki Activity

swarm cmd: port to new cmd lib

Browse Source 
License: MIT
Signed-off-by: Łukasz Magiera <magik6k@gmail.com>
This commit is contained in:
Łukasz Magiera 2018-09-11 20:50:15 +02:00
parent 44bab585a5
commit 30d42f4550
5 changed files with 151 additions and 207 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
core/commands/log.go
View File

@ -1,10 +1,12 @@
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
}

2
core/commands/root.go
View File

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

322
core/commands/swarm.go
View File

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

2
core/coreapi/interface/swarm.go
View File

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

10
core/coreapi/swarm.go
View File

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