Merge pull request #7548 from anikaraghu/anika/p2pflags

fix: pass in env var prefix for p2p flags

op-bootnode/flags/flags.go

@@ -37,7 +37,7 @@ var Flags = []cli.Flag{
 }
 
 func init() {
-	Flags = append(Flags, flags.P2pFlags...)
+	Flags = append(Flags, flags.P2PFlags(envVarPrefix)...)
 	Flags = append(Flags, opmetrics.CLIFlags(envVarPrefix)...)
 	Flags = append(Flags, oplog.CLIFlags(envVarPrefix)...)
 }

op-node/flags/flags.go

@@ -309,7 +309,7 @@ var optionalFlags = []cli.Flag{
 var Flags []cli.Flag
 
 func init() {
-	optionalFlags = append(optionalFlags, P2pFlags...)
+	optionalFlags = append(optionalFlags, P2PFlags(EnvVarPrefix)...)
 	optionalFlags = append(optionalFlags, oplog.CLIFlags(EnvVarPrefix)...)
 	Flags = append(requiredFlags, optionalFlags...)
 }

op-node/p2p/cli/load_config.go

@@ -29,7 +29,7 @@ import (
 func NewConfig(ctx *cli.Context, rollupCfg *rollup.Config) (*p2p.Config, error) {
 	conf := &p2p.Config{}
 
-	if ctx.Bool(flags.DisableP2P.Name) {
+	if ctx.Bool(flags.DisableP2PName) {
 		conf.DisableP2P = true
 		return conf, nil
 	}
@@ -64,7 +64,7 @@ func NewConfig(ctx *cli.Context, rollupCfg *rollup.Config) (*p2p.Config, error)
 		return nil, fmt.Errorf("failed to load banning option: %w", err)
 	}
 
-	conf.EnableReqRespSync = ctx.Bool(flags.SyncReqRespFlag.Name)
+	conf.EnableReqRespSync = ctx.Bool(flags.SyncReqRespName)
 
 	return conf, nil
 }
@@ -84,13 +84,13 @@ func validatePort(p uint) (uint16, error) {
 
 // loadScoringParams loads the peer scoring options from the CLI context.
 func loadScoringParams(conf *p2p.Config, ctx *cli.Context, rollupCfg *rollup.Config) error {
-	scoringLevel := ctx.String(flags.Scoring.Name)
+	scoringLevel := ctx.String(flags.ScoringName)
 	// Check old names for backwards compatibility
 	if scoringLevel == "" {
-		scoringLevel = ctx.String(flags.PeerScoring.Name)
+		scoringLevel = ctx.String(flags.PeerScoringName)
 	}
 	if scoringLevel == "" {
-		scoringLevel = ctx.String(flags.TopicScoring.Name)
+		scoringLevel = ctx.String(flags.TopicScoringName)
 	}
 	if scoringLevel != "" {
 		params, err := p2p.GetScoringParams(scoringLevel, rollupCfg)
@@ -105,14 +105,14 @@ func loadScoringParams(conf *p2p.Config, ctx *cli.Context, rollupCfg *rollup.Con
 
 // loadBanningOptions loads whether or not to ban peers from the CLI context.
 func loadBanningOptions(conf *p2p.Config, ctx *cli.Context) error {
-	conf.BanningEnabled = ctx.Bool(flags.Banning.Name)
-	conf.BanningThreshold = ctx.Float64(flags.BanningThreshold.Name)
-	conf.BanningDuration = ctx.Duration(flags.BanningDuration.Name)
+	conf.BanningEnabled = ctx.Bool(flags.BanningName)
+	conf.BanningThreshold = ctx.Float64(flags.BanningThresholdName)
+	conf.BanningDuration = ctx.Duration(flags.BanningDurationName)
 	return nil
 }
 
 func loadListenOpts(conf *p2p.Config, ctx *cli.Context) error {
-	listenIP := ctx.String(flags.ListenIP.Name)
+	listenIP := ctx.String(flags.ListenIPName)
 	if listenIP != "" { // optional
 		conf.ListenIP = net.ParseIP(listenIP)
 		if conf.ListenIP == nil {
@@ -120,11 +120,11 @@ func loadListenOpts(conf *p2p.Config, ctx *cli.Context) error {
 		}
 	}
 	var err error
-	conf.ListenTCPPort, err = validatePort(ctx.Uint(flags.ListenTCPPort.Name))
+	conf.ListenTCPPort, err = validatePort(ctx.Uint(flags.ListenTCPPortName))
 	if err != nil {
 		return fmt.Errorf("bad listen TCP port: %w", err)
 	}
-	conf.ListenUDPPort, err = validatePort(ctx.Uint(flags.ListenUDPPort.Name))
+	conf.ListenUDPPort, err = validatePort(ctx.Uint(flags.ListenUDPPortName))
 	if err != nil {
 		return fmt.Errorf("bad listen UDP port: %w", err)
 	}
@@ -132,20 +132,20 @@ func loadListenOpts(conf *p2p.Config, ctx *cli.Context) error {
 }
 
 func loadDiscoveryOpts(conf *p2p.Config, ctx *cli.Context) error {
-	if ctx.Bool(flags.NoDiscovery.Name) {
+	if ctx.Bool(flags.NoDiscoveryName) {
 		conf.NoDiscovery = true
 	}
 
 	var err error
-	conf.AdvertiseTCPPort, err = validatePort(ctx.Uint(flags.AdvertiseTCPPort.Name))
+	conf.AdvertiseTCPPort, err = validatePort(ctx.Uint(flags.AdvertiseTCPPortName))
 	if err != nil {
 		return fmt.Errorf("bad advertised TCP port: %w", err)
 	}
-	conf.AdvertiseUDPPort, err = validatePort(ctx.Uint(flags.AdvertiseUDPPort.Name))
+	conf.AdvertiseUDPPort, err = validatePort(ctx.Uint(flags.AdvertiseUDPPortName))
 	if err != nil {
 		return fmt.Errorf("bad advertised UDP port: %w", err)
 	}
-	adIP := ctx.String(flags.AdvertiseIP.Name)
+	adIP := ctx.String(flags.AdvertiseIPName)
 	if adIP != "" { // optional
 		ips, err := net.LookupIP(adIP)
 		if err != nil {
@@ -163,7 +163,7 @@ func loadDiscoveryOpts(conf *p2p.Config, ctx *cli.Context) error {
 		}
 	}
 
-	dbPath := ctx.String(flags.DiscoveryPath.Name)
+	dbPath := ctx.String(flags.DiscoveryPathName)
 	if dbPath == "" {
 		dbPath = "opnode_discovery_db"
 	}
@@ -176,7 +176,7 @@ func loadDiscoveryOpts(conf *p2p.Config, ctx *cli.Context) error {
 	}
 
 	bootnodes := make([]*enode.Node, 0)
-	records := strings.Split(ctx.String(flags.Bootnodes.Name), ",")
+	records := strings.Split(ctx.String(flags.BootnodesName), ",")
 	for i, recordB64 := range records {
 		recordB64 = strings.TrimSpace(recordB64)
 		if recordB64 == "" { // ignore empty records
@@ -194,8 +194,8 @@ func loadDiscoveryOpts(conf *p2p.Config, ctx *cli.Context) error {
 		conf.Bootnodes = p2p.DefaultBootnodes
 	}
 
-	if ctx.IsSet(flags.NetRestrict.Name) {
-		netRestrict, err := netutil.ParseNetlist(ctx.String(flags.NetRestrict.Name))
+	if ctx.IsSet(flags.NetRestrictName) {
+		netRestrict, err := netutil.ParseNetlist(ctx.String(flags.NetRestrictName))
 		if err != nil {
 			return fmt.Errorf("failed to parse net list: %w", err)
 		}
@@ -206,7 +206,7 @@ func loadDiscoveryOpts(conf *p2p.Config, ctx *cli.Context) error {
 }
 
 func loadLibp2pOpts(conf *p2p.Config, ctx *cli.Context) error {
-	addrs := strings.Split(ctx.String(flags.StaticPeers.Name), ",")
+	addrs := strings.Split(ctx.String(flags.StaticPeersName), ",")
 	for i, addr := range addrs {
 		addr = strings.TrimSpace(addr)
 		if addr == "" {
@@ -219,7 +219,7 @@ func loadLibp2pOpts(conf *p2p.Config, ctx *cli.Context) error {
 		conf.StaticPeers = append(conf.StaticPeers, a)
 	}
 
-	for _, v := range strings.Split(ctx.String(flags.HostMux.Name), ",") {
+	for _, v := range strings.Split(ctx.String(flags.HostMuxName), ",") {
 		v = strings.ToLower(strings.TrimSpace(v))
 		switch v {
 		case "yamux":
@@ -231,7 +231,7 @@ func loadLibp2pOpts(conf *p2p.Config, ctx *cli.Context) error {
 		}
 	}
 
-	secArr := strings.Split(ctx.String(flags.HostSecurity.Name), ",")
+	secArr := strings.Split(ctx.String(flags.HostSecurityName), ",")
 	for _, v := range secArr {
 		v = strings.ToLower(strings.TrimSpace(v))
 		switch v {
@@ -249,16 +249,16 @@ func loadLibp2pOpts(conf *p2p.Config, ctx *cli.Context) error {
 		}
 	}
 
-	conf.PeersLo = ctx.Uint(flags.PeersLo.Name)
-	conf.PeersHi = ctx.Uint(flags.PeersHi.Name)
-	conf.PeersGrace = ctx.Duration(flags.PeersGrace.Name)
-	conf.NAT = ctx.Bool(flags.NAT.Name)
-	conf.UserAgent = ctx.String(flags.UserAgent.Name)
-	conf.TimeoutNegotiation = ctx.Duration(flags.TimeoutNegotiation.Name)
-	conf.TimeoutAccept = ctx.Duration(flags.TimeoutAccept.Name)
-	conf.TimeoutDial = ctx.Duration(flags.TimeoutDial.Name)
+	conf.PeersLo = ctx.Uint(flags.PeersLoName)
+	conf.PeersHi = ctx.Uint(flags.PeersHiName)
+	conf.PeersGrace = ctx.Duration(flags.PeersGraceName)
+	conf.NAT = ctx.Bool(flags.NATName)
+	conf.UserAgent = ctx.String(flags.UserAgentName)
+	conf.TimeoutNegotiation = ctx.Duration(flags.TimeoutNegotiationName)
+	conf.TimeoutAccept = ctx.Duration(flags.TimeoutAcceptName)
+	conf.TimeoutDial = ctx.Duration(flags.TimeoutDialName)
 
-	peerstorePath := ctx.String(flags.PeerstorePath.Name)
+	peerstorePath := ctx.String(flags.PeerstorePathName)
 	if peerstorePath == "" {
 		return errors.New("peerstore path must be specified, use 'memory' to explicitly not persist peer records")
 	}
@@ -279,11 +279,11 @@ func loadLibp2pOpts(conf *p2p.Config, ctx *cli.Context) error {
 }
 
 func loadNetworkPrivKey(ctx *cli.Context) (*crypto.Secp256k1PrivateKey, error) {
-	raw := ctx.String(flags.P2PPrivRaw.Name)
+	raw := ctx.String(flags.P2PPrivRawName)
 	if raw != "" {
 		return parsePriv(raw)
 	}
-	keyPath := ctx.String(flags.P2PPrivPath.Name)
+	keyPath := ctx.String(flags.P2PPrivPathName)
 	if keyPath == "" {
 		return nil, errors.New("no p2p private key path specified, cannot auto-generate key without path")
 	}
@@ -333,10 +333,10 @@ func parsePriv(data string) (*crypto.Secp256k1PrivateKey, error) {
 }
 
 func loadGossipOptions(conf *p2p.Config, ctx *cli.Context) error {
-	conf.MeshD = ctx.Int(flags.GossipMeshDFlag.Name)
-	conf.MeshDLo = ctx.Int(flags.GossipMeshDloFlag.Name)
-	conf.MeshDHi = ctx.Int(flags.GossipMeshDhiFlag.Name)
-	conf.MeshDLazy = ctx.Int(flags.GossipMeshDlazyFlag.Name)
-	conf.FloodPublish = ctx.Bool(flags.GossipFloodPublishFlag.Name)
+	conf.MeshD = ctx.Int(flags.GossipMeshDName)
+	conf.MeshDLo = ctx.Int(flags.GossipMeshDloName)
+	conf.MeshDHi = ctx.Int(flags.GossipMeshDhiName)
+	conf.MeshDLazy = ctx.Int(flags.GossipMeshDlazyName)
+	conf.FloodPublish = ctx.Bool(flags.GossipFloodPublishName)
 	return nil
 }

op-node/p2p/cli/load_signer.go

@@ -15,7 +15,7 @@ import (
 
 // LoadSignerSetup loads a configuration for a Signer to be set up later
 func LoadSignerSetup(ctx *cli.Context) (p2p.SignerSetup, error) {
-	key := ctx.String(flags.SequencerP2PKeyFlag.Name)
+	key := ctx.String(flags.SequencerP2PKeyName)
 	if key != "" {
 		// Mnemonics are bad because they leak *all* keys when they leak.
 		// Unencrypted keys from file are bad because they are easy to leak (and we are not checking file permissions).