Double the usefulness interval for peers in the Routing Table (ipfs#651)

* method for getting bootstrap peers and double the usefulness interval

dht.go

@@ -280,7 +280,8 @@ func makeDHT(ctx context.Context, h host.Host, cfg config) (*IpfsDHT, error) {
 	}
 
 	// construct routing table
-	rt, err := makeRoutingTable(dht, cfg, maxLastSuccessfulOutboundThreshold)
+	// use twice the theoritical usefulness threhold to keep older peers around longer
+	rt, err := makeRoutingTable(dht, cfg, 2*maxLastSuccessfulOutboundThreshold)
 	if err != nil {
 		return nil, fmt.Errorf("failed to construct routing table,err=%s", err)
 	}

dht_bootstrap.go

@@ -4,6 +4,8 @@ import (
 	"context"
 	"time"
 
+	"github.com/libp2p/go-libp2p-core/peer"
+
 	"github.com/multiformats/go-multiaddr"
 )
 
@@ -35,6 +37,24 @@ func init() {
 	}
 }
 
+// GetDefaultBootstrapPeerAddrInfos returns the peer.AddrInfos for the default
+// bootstrap peers so we can use these for initializing the DHT by passing these to the
+// BootstrapPeers(...) option.
+func GetDefaultBootstrapPeerAddrInfos() []peer.AddrInfo {
+	ds := make([]peer.AddrInfo, 0, len(DefaultBootstrapPeers))
+
+	for i := range DefaultBootstrapPeers {
+		info, err := peer.AddrInfoFromP2pAddr(DefaultBootstrapPeers[i])
+		if err != nil {
+			logger.Errorw("failed to convert bootstrapper address to peer addr info", "address",
+				DefaultBootstrapPeers[i].String(), err, "err")
+			continue
+		}
+		ds = append(ds, *info)
+	}
+	return ds
+}
+
 // Bootstrap tells the DHT to get into a bootstrapped state satisfying the
 // IpfsRouter interface.
 func (dht *IpfsDHT) Bootstrap(ctx context.Context) error {

dht_bootstrap_test.go

@@ -6,6 +6,7 @@ import (
 	"time"
 
 	"github.com/libp2p/go-libp2p-core/event"
+	"github.com/libp2p/go-libp2p-core/peer"
 	kb "github.com/libp2p/go-libp2p-kbucket"
 
 	"github.com/stretchr/testify/require"
@@ -46,3 +47,24 @@ func TestSelfWalkOnAddressChange(t *testing.T) {
 	require.Contains(t, ps, d2.self)
 	require.Contains(t, ps, d3.self)
 }
+
+func TestDefaultBootstrappers(t *testing.T) {
+	ds := GetDefaultBootstrapPeerAddrInfos()
+	require.NotEmpty(t, ds)
+	require.Len(t, ds, len(DefaultBootstrapPeers))
+
+	dfmap := make(map[peer.ID]peer.AddrInfo)
+	for _, p := range DefaultBootstrapPeers {
+		info, err := peer.AddrInfoFromP2pAddr(p)
+		require.NoError(t, err)
+		dfmap[info.ID] = *info
+	}
+
+	for _, p := range ds {
+		inf, ok := dfmap[p.ID]
+		require.True(t, ok)
+		require.ElementsMatch(t, p.Addrs, inf.Addrs)
+		delete(dfmap, p.ID)
+	}
+	require.Empty(t, dfmap)
+}

dht_options.go

@@ -13,7 +13,6 @@ import (
 	"github.com/libp2p/go-libp2p-core/protocol"
 	"github.com/libp2p/go-libp2p-kad-dht/providers"
 	record "github.com/libp2p/go-libp2p-record"
-	ma "github.com/multiformats/go-multiaddr"
 )
 
 // ModeOpt describes what mode the dht should operate in
@@ -398,12 +397,8 @@ func V1CompatibleMode(enable bool) Option {
 
 // BootstrapPeers configures the bootstrapping nodes that we will connect to to seed
 // and refresh our Routing Table if it becomes empty.
-func BootstrapPeers(addrs ...ma.Multiaddr) Option {
+func BootstrapPeers(bootstrappers ...peer.AddrInfo) Option {
 	return func(c *config) error {
-		bootstrappers, err := peer.AddrInfosFromP2pAddrs(addrs...)
-		if err != nil {
-			return fmt.Errorf("failed to parse bootstrap peer addresses: %w", err)
-		}
 		c.bootstrapPeers = bootstrappers
 		return nil
 	}

dht_test.go

@@ -2021,12 +2021,11 @@ func TestBootStrapWhenRTIsEmpty(t *testing.T) {
 	}
 
 	// convert the bootstrap addresses to a p2p address
-	bootstrapAddrs := make([]ma.Multiaddr, nBootStraps)
+	bootstrapAddrs := make([]peer.AddrInfo, nBootStraps)
 	for i := 0; i < nBootStraps; i++ {
-		b, err := peer.AddrInfoToP2pAddrs(&peer.AddrInfo{ID: bootstrappers[i].self,
-			Addrs: bootstrappers[i].host.Addrs()})
-		require.NoError(t, err)
-		bootstrapAddrs[i] = b[0]
+		b := peer.AddrInfo{ID: bootstrappers[i].self,
+			Addrs: bootstrappers[i].host.Addrs()}
+		bootstrapAddrs[i] = b
 	}
 
 	//----------------