[P2P] [Tooling] Peer discovery peer list subcommand

app/client/cli/cmd.go

@@ -8,7 +8,7 @@ import (
 	"github.com/spf13/viper"
 
 	"github.com/pokt-network/pocket/app/client/cli/flags"
-	"github.com/pokt-network/pocket/runtime/configs"
+	"github.com/pokt-network/pocket/app/client/cli/peer"
 	"github.com/pokt-network/pocket/runtime/defaults"
 )
 
@@ -17,8 +17,6 @@ const (
 	flagBindErrFormat = "could not bind flag %q: %v"
 )
 
-var cfg *configs.Config
-
 func init() {
 	rootCmd.PersistentFlags().StringVar(&flags.RemoteCLIURL, "remote_cli_url", defaults.DefaultRemoteCLIURL, "takes a remote endpoint in the form of <protocol>://<host>:<port> (uses RPC Port)")
 	// ensure that this flag can be overridden by the respective viper-conventional environment variable (i.e. `POCKET_REMOTE_CLI_URL`)
@@ -39,19 +37,17 @@ func init() {
 	if err := viper.BindPFlag("verbose", rootCmd.PersistentFlags().Lookup("verbose")); err != nil {
 		log.Fatalf(flagBindErrFormat, "verbose", err)
 	}
+
+	// Add subdir commands
+	// DISCUSS: Should we put the peer commands as the other commands are so we dont have to do this?
+	rootCmd.AddCommand(peer.NewPeerCommand())
 }
 
 var rootCmd = &cobra.Command{
-	Use:   cliExecutableName,
-	Short: "Pocket Network Command Line Interface (CLI)",
-	Long:  "The CLI is meant to be an user but also a machine friendly way for interacting with Pocket Network.",
-	PersistentPreRunE: func(cmd *cobra.Command, args []string) error {
-		// by this time, the config path should be set
-		cfg = configs.ParseConfig(flags.ConfigPath)
-		// set final `remote_cli_url` value; order of precedence: flag > env var > config > default
-		flags.RemoteCLIURL = viper.GetString("remote_cli_url")
-		return nil
-	},
+	Use:               cliExecutableName,
+	Short:             "Pocket Network Command Line Interface (CLI)",
+	Long:              "The CLI is meant to be an user but also a machine friendly way for interacting with Pocket Network.",
+	PersistentPreRunE: flags.ParseConfigAndFlags,
 }
 
 func ExecuteContext(ctx context.Context) error {

app/client/cli/flags/config.go

@@ -0,0 +1,19 @@
+package flags
+
+import (
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+
+	"github.com/pokt-network/pocket/runtime/configs"
+)
+
+var Cfg *configs.Config
+
+func ParseConfigAndFlags(_ *cobra.Command, _ []string) error {
+	// by this time, the config path should be set
+	Cfg = configs.ParseConfig(ConfigPath)
+
+	// set final `remote_cli_url` value; order of precedence: flag > env var > config > default
+	RemoteCLIURL = viper.GetString("remote_cli_url")
+	return nil
+}

app/client/cli/helpers/common.go

@@ -23,15 +23,14 @@ func FetchPeerstore(cmd *cobra.Command) (types.Peerstore, error) {
 	if err != nil {
 		return nil, err
 	}
-	// TECHDEBT(#811): use `bus.GetPeerstoreProvider()` after peerstore provider
-	// is retrievable as a proper submodule
-	pstoreProvider, err := bus.GetModulesRegistry().GetModule(peerstore_provider.PeerstoreProviderSubmoduleName)
+	// TECHDEBT(#811): Remove type casting once Peerstore is available as a submodule
+	pstoreProvider, err := peerstore_provider.GetPeerstoreProvider(bus)
 	if err != nil {
-		return nil, errors.New("retrieving peerstore provider")
+		return nil, err
 	}
 	currentHeightProvider := bus.GetCurrentHeightProvider()
 	height := currentHeightProvider.CurrentHeight()
-	pstore, err := pstoreProvider.(peerstore_provider.PeerstoreProvider).GetStakedPeerstoreAtHeight(height)
+	pstore, err := pstoreProvider.GetStakedPeerstoreAtHeight(height)
 	if err != nil {
 		return nil, fmt.Errorf("retrieving peerstore at height %d", height)
 	}

app/client/cli/peer/list.go

@@ -0,0 +1,97 @@
+package peer
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+	"google.golang.org/protobuf/types/known/anypb"
+
+	"github.com/pokt-network/pocket/app/client/cli/helpers"
+	"github.com/pokt-network/pocket/logger"
+	"github.com/pokt-network/pocket/p2p/debug"
+	"github.com/pokt-network/pocket/shared/messaging"
+)
+
+var ErrRouterType = fmt.Errorf("must specify one of --staked, --unstaked, or --all")
+
+func NewListCommand() *cobra.Command {
+	return &cobra.Command{
+		Use:     "List",
+		Short:   "List the known peers",
+		Long:    "Prints a table of the Peer ID, Pokt Address and Service URL of the known peers",
+		Aliases: []string{"list", "ls"},
+		RunE:    listRunE,
+	}
+}
+
+func listRunE(cmd *cobra.Command, _ []string) error {
+	var routerType debug.RouterType
+
+	bus, err := helpers.GetBusFromCmd(cmd)
+	if err != nil {
+		return err
+	}
+
+	switch {
+	case stakedFlag && !unstakedFlag && !allFlag:
+		routerType = debug.StakedRouterType
+	case unstakedFlag && !stakedFlag && !allFlag:
+		routerType = debug.UnstakedRouterType
+	case stakedFlag || unstakedFlag:
+		return ErrRouterType
+	// even if `allFlag` is false, we still want to print all connections
+	default:
+		routerType = debug.AllRouterTypes
+	}
+
+	debugMsg := &messaging.DebugMessage{
+		Action: messaging.DebugMessageAction_DEBUG_P2P_PRINT_PEER_LIST,
+		Type:   messaging.DebugMessageRoutingType_DEBUG_MESSAGE_TYPE_BROADCAST,
+		Message: &anypb.Any{
+			Value: []byte(routerType),
+		},
+	}
+	debugMsgAny, err := anypb.New(debugMsg)
+	if err != nil {
+		return fmt.Errorf("error creating anypb from debug message: %w", err)
+	}
+
+	if localFlag {
+		if err := debug.PrintPeerList(bus, routerType); err != nil {
+			return fmt.Errorf("error printing peer list: %w", err)
+		}
+		return nil
+	}
+
+	// TECHDEBT(#811): will need to wait for DHT bootstrapping to complete before
+	// p2p broadcast can be used with to reach unstaked actors.
+	// CONSIDERATION: add the peer commands to the interactive CLI as the P2P module
+	// instance could persist between commands. Other interactive CLI commands which
+	// rely on unstaked actor router broadcast are working as expected.
+
+	// TECHDEBT(#811): use broadcast instead to reach all peers.
+	return sendToStakedPeers(cmd, debugMsgAny)
+}
+
+func sendToStakedPeers(cmd *cobra.Command, debugMsgAny *anypb.Any) error {
+	bus, err := helpers.GetBusFromCmd(cmd)
+	if err != nil {
+		return err
+	}
+
+	pstore, err := helpers.FetchPeerstore(cmd)
+	if err != nil {
+		logger.Global.Fatal().Err(err).Msg("unable to retrieve the pstore")
+	}
+
+	if pstore.Size() == 0 {
+		logger.Global.Fatal().Msg("no validators found")
+	}
+
+	for _, peer := range pstore.GetPeerList() {
+		if err := bus.GetP2PModule().Send(peer.GetAddress(), debugMsgAny); err != nil {
+			logger.Global.Error().Err(err).Msg("failed to send debug message")
+		}
+	}
+	return nil
+}

app/client/cli/peer/peer.go

@@ -0,0 +1,55 @@
+package peer
+
+import (
+	"github.com/spf13/cobra"
+
+	"github.com/pokt-network/pocket/app/client/cli/helpers"
+)
+
+var allFlag,
+	stakedFlag,
+	unstakedFlag,
+	localFlag bool
+
+func NewPeerCommand() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:               "Peer",
+		Short:             "Manage peers",
+		Aliases:           []string{"peer"},
+		PersistentPreRunE: helpers.P2PDependenciesPreRunE,
+	}
+
+	cmd.PersistentFlags().
+		BoolVarP(
+			&allFlag,
+			"all", "a",
+			false,
+			"operations apply to both staked & unstaked router peerstores (default)",
+		)
+	cmd.PersistentFlags().
+		BoolVarP(
+			&stakedFlag,
+			"staked", "s",
+			false,
+			"operations only apply to staked router peerstore (i.e. raintree)",
+		)
+	cmd.PersistentFlags().
+		BoolVarP(
+			&unstakedFlag,
+			"unstaked", "u",
+			false,
+			"operations only apply to unstaked (including staked as a subset) router peerstore (i.e. gossipsub)",
+		)
+	cmd.PersistentFlags().
+		BoolVarP(
+			&localFlag,
+			"local", "l",
+			false,
+			"operations apply to the local (CLI binary's) P2P module instead of being broadcast",
+		)
+
+	// Add subcommands
+	cmd.AddCommand(NewListCommand())
+
+	return cmd
+}

app/client/cli/utils.go

@@ -311,7 +311,7 @@ func attachKeybaseFlagsToSubcommands() []cmdOption {
 }
 
 func keybaseForCLI() (keybase.Keybase, error) {
-	return keybase.NewKeybase(cfg.Keybase)
+	return keybase.NewKeybase(flags.Cfg.Keybase)
 }
 
 func unableToConnectToRpc(err error) error {

charts/pocket/README.md

@@ -46,6 +46,7 @@ privateKeySecretKeyRef:
 | config.fisherman.enabled | bool | `false` |  |
 | config.logger.format | string | `"json"` |  |
 | config.logger.level | string | `"debug"` |  |
+| config.p2p.enable_peer_discovery_debug_rpc | bool | `false` |  |
 | config.p2p.hostname | string | `""` |  |
 | config.p2p.is_empty_connection_type | bool | `false` |  |
 | config.p2p.max_mempool_count | int | `100000` |  |

charts/pocket/templates/statefulset.yaml

@@ -100,10 +100,12 @@ spec:
               valueFrom:
                 fieldRef:
                   fieldPath: status.podIP
-          livenessProbe:
-            httpGet:
-              path: /v1/health
-              port: rpc
+            - name: POCKET_P2P_ENABLE_PEER_DISCOVERY_DEBUG_RPC
+              value: "true"
+#          livenessProbe:
+#            httpGet:
+#              path: /v1/health
+#              port: rpc
           readinessProbe:
             httpGet:
               path: /v1/health

charts/pocket/values.yaml

@@ -101,6 +101,7 @@ config:
     is_empty_connection_type: false
     private_key: "" # @ignored This value is needed but ignored - use privateKeySecretKeyRef instead
     max_mempool_count: 100000
+    enable_peer_discovery_debug_rpc: false
   telemetry:
     enabled: true
     address: 0.0.0.0:9000