2019-07-08 19:07:16 +00:00
|
|
|
package cli
|
|
|
|
|
|
|
|
import (
|
2020-07-31 08:27:22 +00:00
|
|
|
"encoding/json"
|
2019-07-08 19:07:16 +00:00
|
|
|
"fmt"
|
2020-07-31 08:27:22 +00:00
|
|
|
"os"
|
2019-12-11 20:45:19 +00:00
|
|
|
"sort"
|
|
|
|
"strings"
|
2020-09-02 22:25:53 +00:00
|
|
|
"text/tabwriter"
|
2019-07-08 19:07:16 +00:00
|
|
|
|
2020-09-04 11:37:32 +00:00
|
|
|
"github.com/dustin/go-humanize"
|
|
|
|
"github.com/urfave/cli/v2"
|
|
|
|
"golang.org/x/xerrors"
|
|
|
|
|
2020-03-03 04:55:25 +00:00
|
|
|
"github.com/libp2p/go-libp2p-core/peer"
|
2020-09-02 23:31:41 +00:00
|
|
|
protocol "github.com/libp2p/go-libp2p-core/protocol"
|
2020-09-04 11:37:32 +00:00
|
|
|
"github.com/multiformats/go-multiaddr"
|
2020-03-03 04:55:25 +00:00
|
|
|
|
2020-09-04 11:37:32 +00:00
|
|
|
"github.com/filecoin-project/go-address"
|
2019-10-09 03:16:35 +00:00
|
|
|
|
2020-11-13 19:11:17 +00:00
|
|
|
atypes "github.com/filecoin-project/lotus/api"
|
2020-09-04 11:37:32 +00:00
|
|
|
"github.com/filecoin-project/lotus/chain/types"
|
2019-10-18 04:47:41 +00:00
|
|
|
"github.com/filecoin-project/lotus/lib/addrutil"
|
2019-07-08 19:07:16 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
var netCmd = &cli.Command{
|
|
|
|
Name: "net",
|
|
|
|
Usage: "Manage P2P Network",
|
|
|
|
Subcommands: []*cli.Command{
|
2020-08-04 18:57:40 +00:00
|
|
|
NetPeers,
|
2019-07-08 19:07:16 +00:00
|
|
|
netConnect,
|
2020-08-04 18:57:40 +00:00
|
|
|
NetListen,
|
|
|
|
NetId,
|
2020-02-18 19:09:00 +00:00
|
|
|
netFindPeer,
|
2020-06-03 01:13:49 +00:00
|
|
|
netScores,
|
2020-08-13 11:44:03 +00:00
|
|
|
NetReachability,
|
2020-09-02 22:25:53 +00:00
|
|
|
NetBandwidthCmd,
|
2020-11-13 12:27:44 +00:00
|
|
|
NetBlockCmd,
|
2019-07-08 19:07:16 +00:00
|
|
|
},
|
|
|
|
}
|
|
|
|
|
2020-08-04 18:57:40 +00:00
|
|
|
var NetPeers = &cli.Command{
|
2019-07-08 19:07:16 +00:00
|
|
|
Name: "peers",
|
|
|
|
Usage: "Print peers",
|
2020-09-03 23:35:53 +00:00
|
|
|
Flags: []cli.Flag{
|
|
|
|
&cli.BoolFlag{
|
|
|
|
Name: "agent",
|
|
|
|
Aliases: []string{"a"},
|
|
|
|
Usage: "Print agent name",
|
|
|
|
},
|
|
|
|
},
|
2019-07-09 12:19:10 +00:00
|
|
|
Action: func(cctx *cli.Context) error {
|
2019-10-03 18:12:30 +00:00
|
|
|
api, closer, err := GetAPI(cctx)
|
2019-07-10 17:28:49 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2019-10-03 18:12:30 +00:00
|
|
|
defer closer()
|
2019-07-18 23:16:23 +00:00
|
|
|
ctx := ReqContext(cctx)
|
2019-07-09 13:43:21 +00:00
|
|
|
peers, err := api.NetPeers(ctx)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2019-12-11 20:45:19 +00:00
|
|
|
sort.Slice(peers, func(i, j int) bool {
|
|
|
|
return strings.Compare(string(peers[i].ID), string(peers[j].ID)) > 0
|
|
|
|
})
|
|
|
|
|
2019-07-09 13:43:21 +00:00
|
|
|
for _, peer := range peers {
|
2020-09-03 23:35:53 +00:00
|
|
|
var agent string
|
|
|
|
if cctx.Bool("agent") {
|
|
|
|
agent, err = api.NetAgentVersion(ctx, peer.ID)
|
|
|
|
if err != nil {
|
|
|
|
log.Warnf("getting agent version: %s", err)
|
|
|
|
} else {
|
|
|
|
agent = ", " + agent
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fmt.Printf("%s, %s%s\n", peer.ID, peer.Addrs, agent)
|
2020-06-03 01:13:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
var netScores = &cli.Command{
|
|
|
|
Name: "scores",
|
|
|
|
Usage: "Print peers' pubsub scores",
|
2020-07-31 08:27:22 +00:00
|
|
|
Flags: []cli.Flag{
|
|
|
|
&cli.BoolFlag{
|
|
|
|
Name: "extended",
|
|
|
|
Usage: "print extended peer scores in json",
|
|
|
|
},
|
|
|
|
},
|
2020-06-03 01:13:49 +00:00
|
|
|
Action: func(cctx *cli.Context) error {
|
|
|
|
api, closer, err := GetAPI(cctx)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
defer closer()
|
|
|
|
ctx := ReqContext(cctx)
|
|
|
|
scores, err := api.NetPubsubScores(ctx)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2020-07-31 08:27:22 +00:00
|
|
|
if cctx.Bool("extended") {
|
|
|
|
enc := json.NewEncoder(os.Stdout)
|
|
|
|
for _, peer := range scores {
|
|
|
|
err := enc.Encode(peer)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
for _, peer := range scores {
|
|
|
|
fmt.Printf("%s, %f\n", peer.ID, peer.Score.Score)
|
|
|
|
}
|
2019-07-09 13:43:21 +00:00
|
|
|
}
|
2019-07-08 19:07:16 +00:00
|
|
|
|
|
|
|
return nil
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
2020-08-04 18:57:40 +00:00
|
|
|
var NetListen = &cli.Command{
|
2019-07-08 21:01:15 +00:00
|
|
|
Name: "listen",
|
|
|
|
Usage: "List listen addresses",
|
2019-07-09 12:19:10 +00:00
|
|
|
Action: func(cctx *cli.Context) error {
|
2019-10-03 18:12:30 +00:00
|
|
|
api, closer, err := GetAPI(cctx)
|
2019-07-10 17:28:49 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2019-10-03 18:12:30 +00:00
|
|
|
defer closer()
|
2019-07-18 23:16:23 +00:00
|
|
|
ctx := ReqContext(cctx)
|
2019-07-08 21:01:15 +00:00
|
|
|
|
2019-07-09 13:43:21 +00:00
|
|
|
addrs, err := api.NetAddrsListen(ctx)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2019-07-09 17:03:36 +00:00
|
|
|
for _, peer := range addrs.Addrs {
|
|
|
|
fmt.Printf("%s/p2p/%s\n", peer, addrs.ID)
|
2019-07-09 13:43:21 +00:00
|
|
|
}
|
2019-07-08 21:01:15 +00:00
|
|
|
return nil
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
2019-07-08 19:07:16 +00:00
|
|
|
var netConnect = &cli.Command{
|
2019-10-09 20:02:08 +00:00
|
|
|
Name: "connect",
|
|
|
|
Usage: "Connect to a peer",
|
2020-09-04 11:37:32 +00:00
|
|
|
ArgsUsage: "[peerMultiaddr|minerActorAddress]",
|
2019-07-09 12:19:10 +00:00
|
|
|
Action: func(cctx *cli.Context) error {
|
2019-10-03 18:12:30 +00:00
|
|
|
api, closer, err := GetAPI(cctx)
|
2019-07-10 17:28:49 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2019-10-03 18:12:30 +00:00
|
|
|
defer closer()
|
2019-07-18 23:16:23 +00:00
|
|
|
ctx := ReqContext(cctx)
|
2019-07-09 12:19:10 +00:00
|
|
|
|
2019-10-09 03:16:35 +00:00
|
|
|
pis, err := addrutil.ParseAddresses(ctx, cctx.Args().Slice())
|
2019-07-08 19:07:16 +00:00
|
|
|
if err != nil {
|
2020-09-04 11:37:32 +00:00
|
|
|
a, perr := address.NewFromString(cctx.Args().First())
|
|
|
|
if perr != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
na, fc, err := GetFullNodeAPI(cctx)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
defer fc()
|
|
|
|
|
|
|
|
mi, err := na.StateMinerInfo(ctx, a, types.EmptyTSK)
|
|
|
|
if err != nil {
|
|
|
|
return xerrors.Errorf("getting miner info: %w", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
if mi.PeerId == nil {
|
|
|
|
return xerrors.Errorf("no PeerID for miner")
|
|
|
|
}
|
|
|
|
multiaddrs := make([]multiaddr.Multiaddr, 0, len(mi.Multiaddrs))
|
|
|
|
for i, a := range mi.Multiaddrs {
|
|
|
|
maddr, err := multiaddr.NewMultiaddrBytes(a)
|
|
|
|
if err != nil {
|
|
|
|
log.Warnf("parsing multiaddr %d (%x): %s", i, a, err)
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
multiaddrs = append(multiaddrs, maddr)
|
|
|
|
}
|
|
|
|
|
|
|
|
pi := peer.AddrInfo{
|
|
|
|
ID: *mi.PeerId,
|
|
|
|
Addrs: multiaddrs,
|
|
|
|
}
|
|
|
|
|
|
|
|
fmt.Printf("%s -> %s\n", a, pi)
|
|
|
|
|
|
|
|
pis = append(pis, pi)
|
2019-07-08 19:07:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
for _, pi := range pis {
|
2019-07-09 12:19:10 +00:00
|
|
|
fmt.Printf("connect %s: ", pi.ID.Pretty())
|
2019-07-09 12:25:33 +00:00
|
|
|
err := api.NetConnect(ctx, pi)
|
2019-07-08 19:07:16 +00:00
|
|
|
if err != nil {
|
|
|
|
fmt.Println("failure")
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
fmt.Println("success")
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
2020-08-04 18:57:40 +00:00
|
|
|
var NetId = &cli.Command{
|
2019-07-22 17:20:07 +00:00
|
|
|
Name: "id",
|
|
|
|
Usage: "Get node identity",
|
|
|
|
Action: func(cctx *cli.Context) error {
|
2019-10-03 18:12:30 +00:00
|
|
|
api, closer, err := GetAPI(cctx)
|
2019-07-22 17:20:07 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2019-10-03 18:12:30 +00:00
|
|
|
defer closer()
|
2019-07-22 17:20:07 +00:00
|
|
|
|
2019-07-18 23:16:23 +00:00
|
|
|
ctx := ReqContext(cctx)
|
2019-07-22 17:20:07 +00:00
|
|
|
|
|
|
|
pid, err := api.ID(ctx)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
fmt.Println(pid)
|
|
|
|
return nil
|
|
|
|
},
|
|
|
|
}
|
2020-02-18 19:09:00 +00:00
|
|
|
|
|
|
|
var netFindPeer = &cli.Command{
|
|
|
|
Name: "findpeer",
|
|
|
|
Usage: "Find the addresses of a given peerID",
|
2020-03-04 21:46:00 +00:00
|
|
|
ArgsUsage: "[peerId]",
|
2020-02-18 19:09:00 +00:00
|
|
|
Action: func(cctx *cli.Context) error {
|
|
|
|
if cctx.NArg() != 1 {
|
|
|
|
fmt.Println("Usage: findpeer [peer ID]")
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-08-20 04:49:10 +00:00
|
|
|
pid, err := peer.Decode(cctx.Args().First())
|
2020-02-18 19:09:00 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
api, closer, err := GetAPI(cctx)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
defer closer()
|
|
|
|
|
|
|
|
ctx := ReqContext(cctx)
|
|
|
|
|
|
|
|
addrs, err := api.NetFindPeer(ctx, pid)
|
|
|
|
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
fmt.Println(addrs)
|
|
|
|
return nil
|
|
|
|
},
|
|
|
|
}
|
2020-08-13 11:18:14 +00:00
|
|
|
|
2020-08-13 11:44:03 +00:00
|
|
|
var NetReachability = &cli.Command{
|
2020-08-13 11:44:43 +00:00
|
|
|
Name: "reachability",
|
|
|
|
Usage: "Print information about reachability from the internet",
|
2020-08-13 11:18:14 +00:00
|
|
|
Action: func(cctx *cli.Context) error {
|
|
|
|
api, closer, err := GetAPI(cctx)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
defer closer()
|
|
|
|
|
|
|
|
ctx := ReqContext(cctx)
|
|
|
|
|
|
|
|
i, err := api.NetAutoNatStatus(ctx)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
fmt.Println("AutoNAT status: ", i.Reachability.String())
|
2020-08-18 01:12:50 +00:00
|
|
|
if i.PublicAddr != "" {
|
|
|
|
fmt.Println("Public address: ", i.PublicAddr)
|
2020-08-13 11:18:14 +00:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
},
|
|
|
|
}
|
2020-09-02 22:25:53 +00:00
|
|
|
|
|
|
|
var NetBandwidthCmd = &cli.Command{
|
|
|
|
Name: "bandwidth",
|
|
|
|
Usage: "Print bandwidth usage information",
|
|
|
|
Flags: []cli.Flag{
|
|
|
|
&cli.BoolFlag{
|
|
|
|
Name: "by-peer",
|
|
|
|
Usage: "list bandwidth usage by peer",
|
|
|
|
},
|
|
|
|
&cli.BoolFlag{
|
|
|
|
Name: "by-protocol",
|
|
|
|
Usage: "list bandwidth usage by protocol",
|
|
|
|
},
|
|
|
|
},
|
|
|
|
Action: func(cctx *cli.Context) error {
|
|
|
|
api, closer, err := GetAPI(cctx)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
defer closer()
|
|
|
|
|
|
|
|
ctx := ReqContext(cctx)
|
|
|
|
|
|
|
|
bypeer := cctx.Bool("by-peer")
|
|
|
|
byproto := cctx.Bool("by-protocol")
|
|
|
|
|
|
|
|
tw := tabwriter.NewWriter(os.Stdout, 4, 4, 2, ' ', 0)
|
|
|
|
|
|
|
|
fmt.Fprintf(tw, "Segment\tTotalIn\tTotalOut\tRateIn\tRateOut\n")
|
|
|
|
|
|
|
|
if bypeer {
|
|
|
|
bw, err := api.NetBandwidthStatsByPeer(ctx)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
var peers []string
|
|
|
|
for p := range bw {
|
|
|
|
peers = append(peers, p)
|
|
|
|
}
|
|
|
|
|
|
|
|
sort.Slice(peers, func(i, j int) bool {
|
|
|
|
return peers[i] < peers[j]
|
|
|
|
})
|
|
|
|
|
|
|
|
for _, p := range peers {
|
|
|
|
s := bw[p]
|
|
|
|
fmt.Fprintf(tw, "%s\t%s\t%s\t%s/s\t%s/s\n", p, humanize.Bytes(uint64(s.TotalIn)), humanize.Bytes(uint64(s.TotalOut)), humanize.Bytes(uint64(s.RateIn)), humanize.Bytes(uint64(s.RateOut)))
|
|
|
|
}
|
|
|
|
} else if byproto {
|
|
|
|
bw, err := api.NetBandwidthStatsByProtocol(ctx)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
var protos []protocol.ID
|
|
|
|
for p := range bw {
|
|
|
|
protos = append(protos, p)
|
|
|
|
}
|
|
|
|
|
|
|
|
sort.Slice(protos, func(i, j int) bool {
|
|
|
|
return protos[i] < protos[j]
|
|
|
|
})
|
|
|
|
|
|
|
|
for _, p := range protos {
|
|
|
|
s := bw[p]
|
|
|
|
if p == "" {
|
|
|
|
p = "<unknown>"
|
|
|
|
}
|
|
|
|
fmt.Fprintf(tw, "%s\t%s\t%s\t%s/s\t%s/s\n", p, humanize.Bytes(uint64(s.TotalIn)), humanize.Bytes(uint64(s.TotalOut)), humanize.Bytes(uint64(s.RateIn)), humanize.Bytes(uint64(s.RateOut)))
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
|
|
|
|
s, err := api.NetBandwidthStats(ctx)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
fmt.Fprintf(tw, "Total\t%s\t%s\t%s/s\t%s/s\n", humanize.Bytes(uint64(s.TotalIn)), humanize.Bytes(uint64(s.TotalOut)), humanize.Bytes(uint64(s.RateIn)), humanize.Bytes(uint64(s.RateOut)))
|
|
|
|
}
|
|
|
|
|
|
|
|
return tw.Flush()
|
|
|
|
|
|
|
|
},
|
|
|
|
}
|
2020-11-13 12:27:44 +00:00
|
|
|
|
|
|
|
var NetBlockCmd = &cli.Command{
|
|
|
|
Name: "block",
|
|
|
|
Usage: "Manage network connection gating rules",
|
|
|
|
Subcommands: []*cli.Command{
|
|
|
|
NetBlockAddCmd,
|
|
|
|
NetBlockRemoveCmd,
|
|
|
|
NetBlockListCmd,
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
var NetBlockAddCmd = &cli.Command{
|
|
|
|
Name: "add",
|
|
|
|
Usage: "Add connection gating rules",
|
|
|
|
Subcommands: []*cli.Command{
|
|
|
|
NetBlockAddPeer,
|
|
|
|
NetBlockAddIP,
|
|
|
|
NetBlockAddSubnet,
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
var NetBlockAddPeer = &cli.Command{
|
|
|
|
Name: "peer",
|
|
|
|
Usage: "Block a peer",
|
|
|
|
ArgsUsage: "<Peer> ...",
|
|
|
|
Action: func(cctx *cli.Context) error {
|
|
|
|
api, closer, err := GetAPI(cctx)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
defer closer()
|
|
|
|
ctx := ReqContext(cctx)
|
|
|
|
|
|
|
|
var peers []peer.ID
|
|
|
|
for _, s := range cctx.Args().Slice() {
|
|
|
|
p, err := peer.Decode(s)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
peers = append(peers, p)
|
|
|
|
}
|
|
|
|
|
2020-11-13 19:11:17 +00:00
|
|
|
return api.NetBlockAdd(ctx, atypes.NetBlockList{Peers: peers})
|
2020-11-13 12:27:44 +00:00
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
var NetBlockAddIP = &cli.Command{
|
|
|
|
Name: "ip",
|
|
|
|
Usage: "Block an IP address",
|
|
|
|
ArgsUsage: "<IP> ...",
|
|
|
|
Action: func(cctx *cli.Context) error {
|
|
|
|
api, closer, err := GetAPI(cctx)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
defer closer()
|
|
|
|
ctx := ReqContext(cctx)
|
|
|
|
|
2020-11-13 19:11:17 +00:00
|
|
|
return api.NetBlockAdd(ctx, atypes.NetBlockList{IPAddrs: cctx.Args().Slice()})
|
2020-11-13 12:27:44 +00:00
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
var NetBlockAddSubnet = &cli.Command{
|
2020-11-13 12:39:34 +00:00
|
|
|
Name: "subnet",
|
2020-11-13 12:27:44 +00:00
|
|
|
Usage: "Block an IP subnet",
|
|
|
|
ArgsUsage: "<CIDR> ...",
|
|
|
|
Action: func(cctx *cli.Context) error {
|
|
|
|
api, closer, err := GetAPI(cctx)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
defer closer()
|
|
|
|
ctx := ReqContext(cctx)
|
|
|
|
|
2020-11-13 19:11:17 +00:00
|
|
|
return api.NetBlockAdd(ctx, atypes.NetBlockList{IPSubnets: cctx.Args().Slice()})
|
2020-11-13 12:27:44 +00:00
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
var NetBlockRemoveCmd = &cli.Command{
|
2020-11-13 12:39:34 +00:00
|
|
|
Name: "remove",
|
2020-11-13 12:27:44 +00:00
|
|
|
Usage: "Remove connection gating rules",
|
|
|
|
Subcommands: []*cli.Command{
|
|
|
|
NetBlockRemovePeer,
|
|
|
|
NetBlockRemoveIP,
|
|
|
|
NetBlockRemoveSubnet,
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
var NetBlockRemovePeer = &cli.Command{
|
|
|
|
Name: "peer",
|
|
|
|
Usage: "Unblock a peer",
|
|
|
|
ArgsUsage: "<Peer> ...",
|
|
|
|
Action: func(cctx *cli.Context) error {
|
|
|
|
api, closer, err := GetAPI(cctx)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
defer closer()
|
|
|
|
ctx := ReqContext(cctx)
|
|
|
|
|
|
|
|
var peers []peer.ID
|
|
|
|
for _, s := range cctx.Args().Slice() {
|
|
|
|
p, err := peer.Decode(s)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
peers = append(peers, p)
|
|
|
|
}
|
|
|
|
|
2020-11-13 19:11:17 +00:00
|
|
|
return api.NetBlockRemove(ctx, atypes.NetBlockList{Peers: peers})
|
2020-11-13 12:27:44 +00:00
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
var NetBlockRemoveIP = &cli.Command{
|
|
|
|
Name: "ip",
|
|
|
|
Usage: "Unblock an IP address",
|
|
|
|
ArgsUsage: "<IP> ...",
|
|
|
|
Action: func(cctx *cli.Context) error {
|
|
|
|
api, closer, err := GetAPI(cctx)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
defer closer()
|
|
|
|
ctx := ReqContext(cctx)
|
|
|
|
|
2020-11-13 19:11:17 +00:00
|
|
|
return api.NetBlockRemove(ctx, atypes.NetBlockList{IPAddrs: cctx.Args().Slice()})
|
2020-11-13 12:27:44 +00:00
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
var NetBlockRemoveSubnet = &cli.Command{
|
2020-11-13 12:39:34 +00:00
|
|
|
Name: "subnet",
|
2020-11-13 12:27:44 +00:00
|
|
|
Usage: "Unblock an IP subnet",
|
|
|
|
ArgsUsage: "<CIDR> ...",
|
|
|
|
Action: func(cctx *cli.Context) error {
|
|
|
|
api, closer, err := GetAPI(cctx)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
defer closer()
|
|
|
|
ctx := ReqContext(cctx)
|
|
|
|
|
2020-11-13 19:11:17 +00:00
|
|
|
return api.NetBlockRemove(ctx, atypes.NetBlockList{IPSubnets: cctx.Args().Slice()})
|
2020-11-13 12:27:44 +00:00
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
var NetBlockListCmd = &cli.Command{
|
|
|
|
Name: "list",
|
|
|
|
Usage: "list connection gating rules",
|
|
|
|
Action: func(cctx *cli.Context) error {
|
|
|
|
api, closer, err := GetAPI(cctx)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
defer closer()
|
|
|
|
ctx := ReqContext(cctx)
|
|
|
|
|
|
|
|
acl, err := api.NetBlockList(ctx)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
if len(acl.Peers) != 0 {
|
|
|
|
sort.Slice(acl.Peers, func(i, j int) bool {
|
|
|
|
return strings.Compare(string(acl.Peers[i]), string(acl.Peers[j])) > 0
|
|
|
|
})
|
|
|
|
|
|
|
|
fmt.Println("Blocked Peers:")
|
|
|
|
for _, p := range acl.Peers {
|
|
|
|
fmt.Printf("\t%s\n", p)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if len(acl.IPAddrs) != 0 {
|
|
|
|
sort.Slice(acl.IPAddrs, func(i, j int) bool {
|
|
|
|
return strings.Compare(acl.IPAddrs[i], acl.IPAddrs[j]) < 0
|
|
|
|
})
|
|
|
|
|
|
|
|
fmt.Println("Blocked IPs:")
|
|
|
|
for _, a := range acl.IPAddrs {
|
|
|
|
fmt.Printf("\t%s\n", a)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if len(acl.IPSubnets) != 0 {
|
|
|
|
sort.Slice(acl.IPSubnets, func(i, j int) bool {
|
|
|
|
return strings.Compare(acl.IPSubnets[i], acl.IPSubnets[j]) < 0
|
|
|
|
})
|
|
|
|
|
|
|
|
fmt.Println("Blocked Subnets:")
|
|
|
|
for _, n := range acl.IPSubnets {
|
|
|
|
fmt.Printf("\t%s\n", n)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
},
|
|
|
|
}
|