github.com/celestiaorg/celestia-node@v0.15.0-beta.1/nodebuilder/p2p/flags.go (about)

     1  package p2p
     2  
     3  import (
     4  	"fmt"
     5  	"os"
     6  	"strings"
     7  
     8  	"github.com/multiformats/go-multiaddr"
     9  	"github.com/spf13/cobra"
    10  	flag "github.com/spf13/pflag"
    11  )
    12  
    13  // EnvCustomNetwork is the environment variable name used for setting a custom network.
    14  const EnvCustomNetwork = "CELESTIA_CUSTOM"
    15  
    16  const (
    17  	networkFlag = "p2p.network"
    18  	mutualFlag  = "p2p.mutual"
    19  )
    20  
    21  // Flags gives a set of p2p flags.
    22  func Flags() *flag.FlagSet {
    23  	flags := &flag.FlagSet{}
    24  
    25  	flags.StringSlice(
    26  		mutualFlag,
    27  		nil,
    28  		`Comma-separated multiaddresses of mutual peers to keep a prioritized connection with.
    29  Such connection is immune to peer scoring slashing and connection module trimming.
    30  Peers must bidirectionally point to each other. (Format: multiformats.io/multiaddr)
    31  `,
    32  	)
    33  	flags.String(
    34  		networkFlag,
    35  		DefaultNetwork.String(),
    36  		fmt.Sprintf("The name of the network to connect to, e.g. %s. Must be passed on "+
    37  			"both init and start to take effect. Assumes mainnet (%s) unless otherwise specified.",
    38  			listProvidedNetworks(),
    39  			DefaultNetwork.String()),
    40  	)
    41  
    42  	return flags
    43  }
    44  
    45  // ParseFlags parses P2P flags from the given cmd and saves them to the passed config.
    46  func ParseFlags(
    47  	cmd *cobra.Command,
    48  	cfg *Config,
    49  ) error {
    50  	mutualPeers, err := cmd.Flags().GetStringSlice(mutualFlag)
    51  	if err != nil {
    52  		return err
    53  	}
    54  
    55  	for _, peer := range mutualPeers {
    56  		_, err = multiaddr.NewMultiaddr(peer)
    57  		if err != nil {
    58  			return fmt.Errorf("cmd: while parsing '%s': %w", mutualFlag, err)
    59  		}
    60  	}
    61  
    62  	if len(mutualPeers) != 0 {
    63  		cfg.MutualPeers = mutualPeers
    64  	}
    65  	return nil
    66  }
    67  
    68  // ParseNetwork tries to parse the network from the flags and environment,
    69  // and returns either the parsed network or the build's default network
    70  func ParseNetwork(cmd *cobra.Command) (Network, error) {
    71  	if envNetwork, err := parseNetworkFromEnv(); envNetwork != "" {
    72  		return envNetwork, err
    73  	}
    74  	parsed := cmd.Flag(networkFlag).Value.String()
    75  	switch parsed {
    76  	case "":
    77  		return "", fmt.Errorf("no network provided, allowed values: %s", listProvidedNetworks())
    78  
    79  	case DefaultNetwork.String():
    80  		return DefaultNetwork, nil
    81  
    82  	default:
    83  		if net, err := Network(parsed).Validate(); err == nil {
    84  			return net, nil
    85  		}
    86  		return "", fmt.Errorf("invalid network specified: %s, allowed values: %s", parsed, listProvidedNetworks())
    87  	}
    88  }
    89  
    90  // parseNetworkFromEnv tries to parse the network from the environment.
    91  // If no network is set, it returns an empty string.
    92  func parseNetworkFromEnv() (Network, error) {
    93  	var network Network
    94  	// check if custom network option set
    95  	// format: CELESTIA_CUSTOM=<netID>:<genesisHash>:<bootstrapPeerList>
    96  	if custom, ok := os.LookupEnv(EnvCustomNetwork); ok {
    97  		fmt.Print("\n\nWARNING: Celestia custom network specified. Only use this option if the node is " +
    98  			"freshly created and initialized.\n**DO NOT** run a custom network over an already-existing node " +
    99  			"store!\n\n")
   100  		// ensure at least custom network is set
   101  		params := strings.Split(custom, ":")
   102  		if len(params) == 0 {
   103  			return network, fmt.Errorf("params: must provide at least <network_ID> to use a custom network")
   104  		}
   105  		netID := params[0]
   106  		network = Network(netID)
   107  		networksList[network] = struct{}{}
   108  		// check if genesis hash provided and register it if exists
   109  		if len(params) >= 2 {
   110  			genHash := params[1]
   111  			genesisList[network] = strings.ToUpper(genHash)
   112  		}
   113  		// check if bootstrappers were provided and register
   114  		if len(params) == 3 {
   115  			bootstrappers := params[2]
   116  			// validate bootstrappers
   117  			bs := strings.Split(bootstrappers, ",")
   118  			_, err := parseAddrInfos(bs)
   119  			if err != nil {
   120  				return DefaultNetwork, fmt.Errorf("params: env %s: contains invalid multiaddress", EnvCustomNetwork)
   121  			}
   122  			bootstrapList[Network(netID)] = bs
   123  		}
   124  	}
   125  	return network, nil
   126  }