go-libp2p-kad-dht version 2

v2/bootstrap.go

@@ -0,0 +1,34 @@
+package dht
+
+import (
+	"github.com/libp2p/go-libp2p/core/peer"
+)
+
+// defaultBootstrapPeers is a set of hard-coded public DHT bootstrap peers
+// operated by Protocol Labs. This slice is filled in the init() method.
+var defaultBootstrapPeers []peer.AddrInfo
+
+func init() {
+	for _, s := range []string{
+		"/dnsaddr/bootstrap.libp2p.io/p2p/QmNnooDu7bfjPFoTZYxMNLWUQJyrVwtbZg5gBMjTezGAJN",
+		"/dnsaddr/bootstrap.libp2p.io/p2p/QmQCU2EcMqAqQPR2i9bChDtGNJchTbq5TbXJJ16u19uLTa",
+		"/dnsaddr/bootstrap.libp2p.io/p2p/QmbLHAnMoJPWSCR5Zhtx6BHJX9KiKNN6tpvbUcqanj75Nb",
+		"/dnsaddr/bootstrap.libp2p.io/p2p/QmcZf59bWwK5XFi76CZX8cbJ4BhTzzA3gU1ZjYZcYW3dwt",
+		"/ip4/104.131.131.82/tcp/4001/p2p/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ", // mars.i.ipfs.io
+	} {
+		addrInfo, err := peer.AddrInfoFromString(s)
+		if err != nil {
+			panic(err)
+		}
+		defaultBootstrapPeers = append(defaultBootstrapPeers, *addrInfo)
+	}
+}
+
+// DefaultBootstrapPeers returns hard-coded public DHT bootstrap peers operated
+// by Protocol Labs. You can configure your own set of bootstrap peers by
+// overwriting the corresponding Config field.
+func DefaultBootstrapPeers() []peer.AddrInfo {
+	peers := make([]peer.AddrInfo, len(defaultBootstrapPeers))
+	copy(peers, defaultBootstrapPeers)
+	return peers
+}

v2/bootstrap_test.go

@@ -0,0 +1,23 @@
+package dht
+
+import (
+	"testing"
+
+	"github.com/libp2p/go-libp2p/core/peer"
+)
+
+func TestDefaultBootstrapPeers(t *testing.T) {
+	bps := DefaultBootstrapPeers()
+	if len(bps) != len(defaultBootstrapPeers) {
+		t.Errorf("len(DefaultBootstrapPeers()) = %d, want %v", len(bps), len(defaultBootstrapPeers))
+	}
+
+	bpmap := make(map[peer.ID]peer.AddrInfo)
+	for _, info := range bps {
+		bpmap[info.ID] = info
+	}
+
+	if len(bpmap) != len(defaultBootstrapPeers) {
+		t.Errorf("unique DefaultBootstrapPeers() = %d, want %v", len(bpmap), len(defaultBootstrapPeers))
+	}
+}

v2/config.go

@@ -0,0 +1,105 @@
+package dht
+
+import (
+	"fmt"
+
+	"github.com/plprobelab/go-kademlia/coord"
+	"github.com/plprobelab/go-kademlia/kad"
+	"github.com/plprobelab/go-kademlia/key"
+)
+
+type (
+	// ModeOpt describes in which mode this DHT process should operate in.
+	// Possible options are client, server, and any variant that switches
+	// between both automatically based on public reachability. The DHT receives
+	// reachability updates from libp2p via the EvtLocalReachabilityChanged
+	// event. A DHT that operates in client mode won't register a stream handler
+	// for incoming requests and therefore won't store, e.g., any provider or
+	// IPNS records. A DHT in server mode, on the other hand, does all of that.
+	//
+	// The `mode` type, on the other hand, captures the current state that the
+	// DHT is in. This can either be client or server.
+	ModeOpt string
+
+	// mode describes in which mode the DHT currently operates. Because the ModeOpt
+	// type has options that automatically switch between client and server mode
+	// based on public connectivity, the DHT mode at any point in time can differ
+	// from the desired mode. Therefore, we define this second mode type that
+	// only has the two forms: client or server.
+	mode string
+)
+
+const (
+	// ModeOptClient configures the DHT to only operate in client mode
+	// regardless of potential public reachability.
+	ModeOptClient ModeOpt = "client"
+
+	// ModeOptServer configures the DHT to always operate in server mode
+	// regardless of potentially not being publicly reachable.
+	ModeOptServer ModeOpt = "server"
+
+	// ModeOptAutoClient configures the DHT to start operating in client mode
+	// and if publicly reachability is detected to switch to server mode.
+	ModeOptAutoClient ModeOpt = "auto-client"
+
+	// ModeOptAutoServer configures the DHT to start operating in server mode,
+	// and if it is detected that we don't have public reachability switch
+	// to client mode.
+	ModeOptAutoServer ModeOpt = "auto-server"
+
+	// modeClient means that the DHT is currently operating in client mode.
+	// For more information, check ModeOpt documentation.
+	modeClient mode = "client"
+
+	// modeServer means that the DHT is currently operating in server mode.
+	// For more information, check ModeOpt documentation.
+	modeServer mode = "server"
+)
+
+// Config contains all the configuration options for a DHT. Use DefaultConfig
+// to build up your own configuration struct. The DHT constructor New uses the
+// below method Validate to test for violations of configuration invariants.
+type Config struct {
+	// Mode defines if the DHT should operate as a server or client or switch
+	// between both automatically (see ModeOpt).
+	Mode ModeOpt
+
+	// Kademlia holds the configuration of the underlying Kademlia implementation.
+	Kademlia *coord.Config
+
+	// RoutingTable holds a reference to the specific routing table
+	// implementation that this DHT should use. If this field is nil, the
+	// triert.TrieRT routing table will be used.
+	RoutingTable kad.RoutingTable[key.Key256, kad.NodeID[key.Key256]]
+}
+
+// DefaultConfig returns a configuration struct that can be used as-is to
+// instantiate a fully functional DHT client.
+func DefaultConfig() *Config {
+	return &Config{
+		Mode:         ModeOptAutoClient,
+		Kademlia:     coord.DefaultConfig(),
+		RoutingTable: nil,
+	}
+}
+
+// Validate validates the configuration struct it is called on. It returns
+// an error if any configuration issue was detected and nil if this is
+// a valid configuration.
+func (c *Config) Validate() error {
+	switch c.Mode {
+	case ModeOptClient, ModeOptServer, ModeOptAutoClient, ModeOptAutoServer:
+	default:
+		return fmt.Errorf("invalid mode option: %s", c.Mode)
+	}
+
+	if c.Kademlia == nil {
+		return fmt.Errorf("kademlia configuration must not be nil")
+	}
+
+	if err := c.Kademlia.Validate(); err != nil {
+		return fmt.Errorf("invalid kademlia configuration: %w", err)
+	}
+
+	return nil
+}

v2/config_test.go

@@ -0,0 +1,52 @@
+package dht
+
+import (
+	"testing"
+)
+
+func TestConfig_Validate(t *testing.T) {
+	tests := []struct {
+		name    string
+		mutate  func(*Config) *Config
+		wantErr bool
+	}{
+		{
+			name:    "happy path",
+			wantErr: false,
+			mutate:  func(c *Config) *Config { return c },
+		},
+		{
+			name:    "invalid mode",
+			wantErr: true,
+			mutate: func(c *Config) *Config {
+				c.Mode = "invalid"
+				return c
+			},
+		},
+		{
+			name:    "nil Kademlia configuration",
+			wantErr: true,
+			mutate: func(c *Config) *Config {
+				c.Kademlia = nil
+				return c
+			},
+		},
+		{
+			name:    "invalid Kademlia configuration",
+			wantErr: true,
+			mutate: func(c *Config) *Config {
+				c.Kademlia.Clock = nil
+				return c
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			c := DefaultConfig()
+			c = tt.mutate(c)
+			if err := c.Validate(); (err != nil) != tt.wantErr {
+				t.Errorf("Validate() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}

v2/dht.go

@@ -0,0 +1,82 @@
+package dht
+
+import (
+	"fmt"
+
+	"github.com/libp2p/go-libp2p/core/host"
+	ma "github.com/multiformats/go-multiaddr"
+	"github.com/plprobelab/go-kademlia/coord"
+	"github.com/plprobelab/go-kademlia/kad"
+	"github.com/plprobelab/go-kademlia/key"
+	"github.com/plprobelab/go-kademlia/routing/triert"
+)
+
+// DHT is an implementation of Kademlia with S/Kademlia modifications.
+// It is used to implement the base Routing module.
+type DHT struct {
+	// host holds a reference to the underlying libp2p host
+	host host.Host
+
+	// cfg holds a reference to the DHT configuration struct
+	cfg *Config
+
+	// mode indicates the current mode the DHT operates in. This can differ from
+	// the desired mode if set to auto-client or auto-server. The desired mode
+	// can be configured via the Config struct.
+	mode mode
+
+	// kad is a reference to the go-kademlia coordinator
+	kad *coord.Coordinator[key.Key256, ma.Multiaddr]
+
+	// rt holds a reference to the routing table implementation. This can be
+	// configured via the Config struct.
+	rt kad.RoutingTable[key.Key256, kad.NodeID[key.Key256]]
+}
+
+// New constructs a new DHT for the given underlying host and with the given
+// configuration. Use DefaultConfig() to construct a configuration.
+func New(h host.Host, cfg *Config) (*DHT, error) {
+	var err error
+
+	// check if the configuration is valid
+	if err = cfg.Validate(); err != nil {
+		return nil, fmt.Errorf("validate DHT config: %w", err)
+	}
+
+	d := &DHT{
+		host: h,
+		cfg:  cfg,
+	}
+
+	nid := nodeID(d.host.ID())
+
+	// Use the configured routing table if it was provided
+	if cfg.RoutingTable != nil {
+		d.rt = cfg.RoutingTable
+	} else {
+		rtCfg := triert.DefaultConfig[key.Key256, kad.NodeID[key.Key256]]()
+		d.rt, err = triert.New[key.Key256, kad.NodeID[key.Key256]](nid, rtCfg)
+		if err != nil {
+			return nil, fmt.Errorf("new trie routing table: %w", err)
+		}
+	}
+
+	// instantiate a new Kademlia DHT coordinator.
+	d.kad, err = coord.NewCoordinator[key.Key256, ma.Multiaddr](nid, nil, d.rt, cfg.Kademlia)
+	if err != nil {
+		return nil, fmt.Errorf("new coordinator: %w", err)
+	}
+
+	// determine mode to start in
+	switch cfg.Mode {
+	case ModeOptClient, ModeOptAutoClient:
+		d.mode = modeClient
+	case ModeOptServer, ModeOptAutoServer:
+		d.mode = modeServer
+	default:
+		// should never happen because of the configuration validation above
+		return nil, fmt.Errorf("invalid dht mode %s", cfg.Mode)
+	}
+
+	return d, nil
+}

v2/dht_test.go

@@ -0,0 +1,78 @@
+package dht
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/libp2p/go-libp2p"
+)
+
+func TestNew(t *testing.T) {
+	h, err := libp2p.New(libp2p.NoListenAddrs)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	tests := []struct {
+		name        string
+		cfgBuilder  func(*Config) *Config
+		wantBuilder func(*DHT) *DHT
+		wantErr     bool
+	}{
+		{
+			name:        "happy path",
+			cfgBuilder:  func(c *Config) *Config { return c },
+			wantBuilder: func(dht *DHT) *DHT { return dht },
+			wantErr:     false,
+		},
+		{
+			name: "mode set to server",
+			cfgBuilder: func(c *Config) *Config {
+				c.Mode = ModeOptServer
+				return c
+			},
+			wantBuilder: func(dht *DHT) *DHT {
+				dht.mode = modeServer
+				return dht
+			},
+			wantErr: false,
+		},
+		{
+			name: "mode set to auto client",
+			cfgBuilder: func(c *Config) *Config {
+				c.Mode = ModeOptAutoClient
+				return c
+			},
+			wantBuilder: func(dht *DHT) *DHT {
+				dht.mode = modeClient
+				return dht
+			},
+			wantErr: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			c := DefaultConfig()
+			d, err := New(h, c)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			got, err := New(h, tt.cfgBuilder(c))
+			if (err != nil) != tt.wantErr {
+				t.Errorf("New() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+
+			want := tt.wantBuilder(d)
+
+			want.kad = nil
+			got.kad = nil
+
+			if !reflect.DeepEqual(got, want) {
+				t.Errorf("New() got = %v, want %v", got, want)
+			}
+		})
+	}
+}