use a shared black hole detector

Author: sukunrt

config/config.go

@@ -134,6 +134,11 @@ type Config struct {
 	DisableIdentifyAddressDiscovery bool
 
 	DisableAutoNATv2 bool
+
+	UDPBlackHoleFilter        *swarm.BlackHoleFilter
+	CustomUDPBlackHoleFilter  bool
+	IPv6BlackHoleFilter       *swarm.BlackHoleFilter
+	CustomIPv6BlackHoleFilter bool
 }
 
 func (cfg *Config) makeSwarm(eventBus event.Bus, enableMetrics bool) (*swarm.Swarm, error) {
@@ -168,7 +173,10 @@ func (cfg *Config) makeSwarm(eventBus event.Bus, enableMetrics bool) (*swarm.Swa
 		return nil, err
 	}
 
-	opts := cfg.SwarmOpts
+	opts := append(cfg.SwarmOpts,
+		swarm.WithUDPBlackHoleFilter(cfg.UDPBlackHoleFilter),
+		swarm.WithIPv6BlackHoleFilter(cfg.IPv6BlackHoleFilter),
+	)
 	if cfg.Reporter != nil {
 		opts = append(opts, swarm.WithMetrics(cfg.Reporter))
 	}
@@ -196,7 +204,7 @@ func (cfg *Config) makeSwarm(eventBus event.Bus, enableMetrics bool) (*swarm.Swa
 	return swarm.NewSwarm(pid, cfg.Peerstore, eventBus, opts...)
 }
 
-func (cfg *Config) makeAutoNATHost() (host.Host, error) {
+func (cfg *Config) makeAutoNATV2Host() (host.Host, error) {
 	autonatPrivKey, _, err := crypto.GenerateEd25519Key(rand.Reader)
 	if err != nil {
 		return nil, err
@@ -207,21 +215,21 @@ func (cfg *Config) makeAutoNATHost() (host.Host, error) {
 	}
 
 	autoNatCfg := Config{
-		Transports:         cfg.Transports,
-		Muxers:             cfg.Muxers,
-		SecurityTransports: cfg.SecurityTransports,
-		Insecure:           cfg.Insecure,
-		PSK:                cfg.PSK,
-		ConnectionGater:    cfg.ConnectionGater,
-		Reporter:           cfg.Reporter,
-		PeerKey:            autonatPrivKey,
-		Peerstore:          ps,
-		DialRanker:         swarm.NoDelayDialRanker,
+		Transports:          cfg.Transports,
+		Muxers:              cfg.Muxers,
+		SecurityTransports:  cfg.SecurityTransports,
+		Insecure:            cfg.Insecure,
+		PSK:                 cfg.PSK,
+		ConnectionGater:     cfg.ConnectionGater,
+		Reporter:            cfg.Reporter,
+		PeerKey:             autonatPrivKey,
+		Peerstore:           ps,
+		DialRanker:          swarm.NoDelayDialRanker,
+		UDPBlackHoleFilter:  cfg.UDPBlackHoleFilter,
+		IPv6BlackHoleFilter: cfg.IPv6BlackHoleFilter,
 		SwarmOpts: []swarm.Option{
-			// Disable black hole detection on autonat dialers
-			// It is better to attempt a dial and fail for AutoNAT use cases
-			swarm.WithUDPBlackHoleConfig(false, 0, 0),
-			swarm.WithIPv6BlackHoleConfig(false, 0, 0),
+			// Don't update black hole state for failed autonat dials
+			swarm.WithReadOnlyBlackHoleDetector(),
 		},
 	}
 	fxopts, err := autoNatCfg.addTransports()
@@ -366,7 +374,7 @@ func (cfg *Config) addTransports() ([]fx.Option, error) {
 func (cfg *Config) newBasicHost(swrm *swarm.Swarm, eventBus event.Bus) (*bhost.BasicHost, error) {
 	var autonatv2Dialer host.Host
 	if !cfg.DisableAutoNATv2 {
-		ah, err := cfg.makeAutoNATHost()
+		ah, err := cfg.makeAutoNATV2Host()
 		if err != nil {
 			return nil, err
 		}
@@ -564,9 +572,8 @@ func (cfg *Config) addAutoNAT(h *bhost.BasicHost) error {
 			Peerstore:          ps,
 			DialRanker:         swarm.NoDelayDialRanker,
 			SwarmOpts: []swarm.Option{
-				// It is better to disable black hole detection and just attempt a dial for autonat
-				swarm.WithUDPBlackHoleConfig(false, 0, 0),
-				swarm.WithIPv6BlackHoleConfig(false, 0, 0),
+				swarm.WithUDPBlackHoleFilter(nil),
+				swarm.WithIPv6BlackHoleFilter(nil),
 			},
 		}
 

core/network/network.go

@@ -161,20 +161,6 @@ type Network interface {
 	ResourceManager() ResourceManager
 }
 
-// Dialability indicates how dialable a (peer, addr) combination is.
-type Dialability int
-
-const (
-	// DialabilityUnknown indicates that the dialer cannot dial the (peer, addr) combination
-	DialabilityUnknown Dialability = iota
-
-	// DialabilityDialable indicates that the dialer can dial the (peer, addr) combination
-	DialabilityDialable
-
-	// DialabilityUndialable indicates that the dialer cannot dial the (peer, addr) combinaton
-	DialabilityUndialable
-)
-
 // Dialer represents a service that can dial out to peers
 // (this is usually just a Network, but other services may not need the whole
 // stack, and thus it becomes easier to mock)
@@ -210,7 +196,7 @@ type Dialer interface {
 	StopNotify(Notifiee)
 
 	// CanDial returns whether the dialer can dial peer p at addr
-	CanDial(p peer.ID, addr ma.Multiaddr) Dialability
+	CanDial(p peer.ID, addr ma.Multiaddr) bool
 }
 
 // AddrDelay provides an address along with the delay after which the address

defaults.go

@@ -10,6 +10,7 @@ import (
 	rcmgr "github.com/libp2p/go-libp2p/p2p/host/resource-manager"
 	"github.com/libp2p/go-libp2p/p2p/muxer/yamux"
 	"github.com/libp2p/go-libp2p/p2p/net/connmgr"
+	"github.com/libp2p/go-libp2p/p2p/net/swarm"
 	"github.com/libp2p/go-libp2p/p2p/security/noise"
 	tls "github.com/libp2p/go-libp2p/p2p/security/tls"
 	quic "github.com/libp2p/go-libp2p/p2p/transport/quic"
@@ -133,6 +134,18 @@ var DefaultPrometheusRegisterer = func(cfg *Config) error {
 	return cfg.Apply(PrometheusRegisterer(prometheus.DefaultRegisterer))
 }
 
+var defaultUDPBlackHoleDetector = func(cfg *Config) error {
+	// A black hole is a binary property. On a network if UDP dials are blocked, all dials will
+	// fail. So a low success rate of 5 out 100 dials is good enough.
+	return cfg.Apply(UDPBlackHoleFilter(&swarm.BlackHoleFilter{N: 100, MinSuccesses: 5, Name: "UDP"}))
+}
+
+var defaultIPv6BlackHoleDetector = func(cfg *Config) error {
+	// A black hole is a binary property. On a network if there is no IPv6 connectivity, all
+	// dials will fail. So a low success rate of 5 out 100 dials is good enough.
+	return cfg.Apply(IPv6BlackHoleFilter(&swarm.BlackHoleFilter{N: 100, MinSuccesses: 5, Name: "IPv6"}))
+}
+
 // Complete list of default options and when to fallback on them.
 //
 // Please *DON'T* specify default options any other way. Putting this all here
@@ -189,6 +202,18 @@ var defaults = []struct {
 		fallback: func(cfg *Config) bool { return !cfg.DisableMetrics && cfg.PrometheusRegisterer == nil },
 		opt:      DefaultPrometheusRegisterer,
 	},
+	{
+		fallback: func(cfg *Config) bool {
+			return !cfg.CustomUDPBlackHoleFilter && cfg.UDPBlackHoleFilter == nil
+		},
+		opt: defaultUDPBlackHoleDetector,
+	},
+	{
+		fallback: func(cfg *Config) bool {
+			return !cfg.CustomIPv6BlackHoleFilter && cfg.IPv6BlackHoleFilter == nil
+		},
+		opt: defaultIPv6BlackHoleDetector,
+	},
 }
 
 // Defaults configures libp2p to use the default options. Can be combined with

options.go

@@ -617,3 +617,21 @@ func DisableAutoNATv2() Option {
 		return nil
 	}
 }
+
+// UDPBlackHoleFilter configures libp2p to use f as the black hole filter for UDP addrs
+func UDPBlackHoleFilter(f *swarm.BlackHoleFilter) Option {
+	return func(cfg *Config) error {
+		cfg.UDPBlackHoleFilter = f
+		cfg.CustomUDPBlackHoleFilter = true
+		return nil
+	}
+}
+
+// IPv6BlackHoleFilter configures libp2p to use f as the black hole filter for IPv6 addrs
+func IPv6BlackHoleFilter(f *swarm.BlackHoleFilter) Option {
+	return func(cfg *Config) error {
+		cfg.IPv6BlackHoleFilter = f
+		cfg.CustomIPv6BlackHoleFilter = true
+		return nil
+	}
+}

p2p/net/mock/mock_peernet.go

@@ -435,6 +435,6 @@ func (pn *peernet) ResourceManager() network.ResourceManager {
 	return &network.NullResourceManager{}
 }
 
-func (pn *peernet) CanDial(p peer.ID, addr ma.Multiaddr) network.Dialability {
-	return network.DialabilityUnknown
+func (pn *peernet) CanDial(p peer.ID, addr ma.Multiaddr) bool {
+	return true
 }