Added perPeerRateLimit env config

config/config.go

@@ -104,6 +104,9 @@ type Config struct {
 
 	EnableHolePunching  bool
 	HolePunchingOptions []holepunch.Option
+
+	FDLimit      int
+	PerPeerLimit int
 }
 
 func (cfg *Config) makeSwarm() (*swarm.Swarm, error) {
@@ -151,6 +154,12 @@ func (cfg *Config) makeSwarm() (*swarm.Swarm, error) {
 	if cfg.ResourceManager != nil {
 		opts = append(opts, swarm.WithResourceManager(cfg.ResourceManager))
 	}
+	if cfg.FDLimit != 0 {
+		opts = append(opts, swarm.WithFDLimit(cfg.FDLimit))
+	}
+	if cfg.PerPeerLimit != 0 {
+		opts = append(opts, swarm.WithPerPeerLimit(cfg.PerPeerLimit))
+	}
 	// TODO: Make the swarm implementation configurable.
 	return swarm.NewSwarm(pid, cfg.Peerstore, opts...)
 }

options.go

@@ -477,3 +477,17 @@ func WithDialTimeout(t time.Duration) Option {
 		return nil
 	}
 }
+
+func WithPerPeerLimit(perPeerLimit int) Option {
+	return func(cfg *Config) error {
+		cfg.PerPeerLimit = perPeerLimit
+		return nil
+	}
+}
+
+func WithFDLimit(fdLimit int) Option {
+	return func(cfg *Config) error {
+		cfg.FDLimit = fdLimit
+		return nil
+	}
+}

p2p/net/swarm/limiter.go

@@ -2,8 +2,6 @@ package swarm
 
 import (
 	"context"
-	"os"
-	"strconv"
 	"sync"
 	"time"
 
@@ -47,16 +45,6 @@ type dialLimiter struct {
 
 type dialfunc func(context.Context, peer.ID, ma.Multiaddr) (transport.CapableConn, error)
 
-func newDialLimiter(df dialfunc) *dialLimiter {
-	fd := ConcurrentFdDials
-	if env := os.Getenv("LIBP2P_SWARM_FD_LIMIT"); env != "" {
-		if n, err := strconv.ParseInt(env, 10, 32); err == nil {
-			fd = int(n)
-		}
-	}
-	return newDialLimiterWithParams(df, fd, DefaultPerPeerRateLimit)
-}
-
 func newDialLimiterWithParams(df dialfunc, fdLimit, perPeerLimit int) *dialLimiter {
 	return &dialLimiter{
 		fdLimit:            fdLimit,

p2p/net/swarm/swarm.go

@@ -83,6 +83,20 @@ func WithResourceManager(m network.ResourceManager) Option {
 	}
 }
 
+func WithPerPeerLimit(perPeerLimit int) Option {
+	return func(s *Swarm) error {
+		s.perPeerLimit = perPeerLimit
+		return nil
+	}
+}
+
+func WithFDLimit(fdLimit int) Option {
+	return func(s *Swarm) error {
+		s.fdLimit = fdLimit
+		return nil
+	}
+}
+
 // Swarm is a connection muxer, allowing connections to other peers to
 // be opened and closed, while still using the same Chan for all
 // communication. The Chan sends/receives Messages, which note the
@@ -141,6 +155,10 @@ type Swarm struct {
 	ctxCancel context.CancelFunc
 
 	bwc metrics.Reporter
+
+	// dial limiter
+	perPeerLimit int
+	fdLimit      int
 }
 
 // NewSwarm constructs a Swarm.
@@ -153,6 +171,8 @@ func NewSwarm(local peer.ID, peers peerstore.Peerstore, opts ...Option) (*Swarm,
 		ctxCancel:        cancel,
 		dialTimeout:      defaultDialTimeout,
 		dialTimeoutLocal: defaultDialTimeoutLocal,
+		perPeerLimit:     DefaultPerPeerRateLimit,
+		fdLimit:          ConcurrentFdDials,
 	}
 
 	s.conns.m = make(map[peer.ID][]*Conn)
@@ -170,7 +190,7 @@ func NewSwarm(local peer.ID, peers peerstore.Peerstore, opts ...Option) (*Swarm,
 	}
 
 	s.dsync = newDialSync(s.dialWorkerLoop)
-	s.limiter = newDialLimiter(s.dialAddr)
+	s.limiter = newDialLimiterWithParams(s.dialAddr, s.fdLimit, s.perPeerLimit)
 	s.backf.init(s.ctx)
 	return s, nil
 }