Gossip V3

p2p/dht/bootstrap.go

@@ -63,7 +63,7 @@ func (d *KadDHT) Bootstrap(ctx context.Context) error {
 		return ErrConnectToBootNode
 	}
 
-	d.local.Debug("lookup using %d preloaded bootnodes ", bn)
+	d.local.Debug("Lookup using %d preloaded bootnodes ", bn)
 
 	ctx, _ = context.WithTimeout(ctx, BootstrapTimeout)
 	err := d.tryBoot(ctx, c)

p2p/dht/dht.go

@@ -14,6 +14,8 @@ import (
 // DHT is an interface to a general distributed hash table.
 type DHT interface {
 	Update(node node.Node)
+
+	InternalLookup(dhtid node.DhtID) []node.Node
 	Lookup(pubkey string) (node.Node, error)
 
 	SelectPeers(qty int) []node.Node
@@ -52,8 +54,7 @@ func (d *KadDHT) Size() int {
 	return <-req
 }
 
-// SelectPeers asks routingtable to randomly select a slice of nodes in size `qty`
-// SelectPeers asks routingtable to randomly select a slice of nodes in size `qty`
+// SelectPeers asks routing table to randomly select a slice of nodes in size `qty`
 func (d *KadDHT) SelectPeers(qty int) []node.Node {
 	return d.rt.SelectPeers(qty)
 }
@@ -70,7 +71,7 @@ func New(node *node.LocalNode, config config.SwarmConfig, service service.Servic
 	return d
 }
 
-// Update insert or update a node in the routing table.
+// Update insert or updates a node in the routing table.
 func (d *KadDHT) Update(node node.Node) {
 	d.rt.Update(node)
 }
@@ -79,11 +80,11 @@ func (d *KadDHT) Update(node node.Node) {
 // if the node can't be found there it sends a query to the network.
 func (d *KadDHT) Lookup(pubkey string) (node.Node, error) {
 	dhtid := node.NewDhtIDFromBase58(pubkey)
-	poc := make(PeersOpChannel)
-	d.rt.NearestPeers(NearestPeersReq{dhtid, d.config.RoutingTableAlpha, poc})
-	res := (<-poc).Peers
-	if len(res) == 0 {
-		return node.EmptyNode, ErrEmptyRoutingTable
+
+	res := d.InternalLookup(dhtid)
+
+	if res == nil {
+		return node.EmptyNode, errors.New("no peers found in routing table")
 	}
 
 	if res[0].DhtID().Equals(dhtid) {
@@ -92,6 +93,16 @@ func (d *KadDHT) Lookup(pubkey string) (node.Node, error) {
 
 	return d.kadLookup(pubkey, res)
 }
+// InternalLookup finds a node in the dht by its public key, it issues a search inside the local routing table
+func (d *KadDHT) InternalLookup(dhtid node.DhtID) []node.Node {
+	poc := make(PeersOpChannel)
+	d.rt.NearestPeers(NearestPeersReq{dhtid, d.config.RoutingTableAlpha, poc})
+	res := (<-poc).Peers
+	if len(res) == 0 {
+		return nil
+	}
+	return res
+}
 
 // Implements the kad algo for locating a remote node
 // Precondition - node is not in local routing table

p2p/dht/dht_mock.go

@@ -1,20 +1,26 @@
 package dht
 
-import "github.com/spacemeshos/go-spacemesh/p2p/node"
+import (
+	"context"
+	"github.com/spacemeshos/go-spacemesh/p2p/node"
+)
 
 // MockDHT is a mocked dht
 type MockDHT struct {
-	update      func(n node.Node)
-	updateCount int
-	bsres       error
-	bsCount     int
-	lookupRes   node.Node
-	lookupErr   error
+	UpdateFunc         func(n node.Node)
+	updateCount        int
+	SelectPeersFunc func(qty int) []node.Node
+	bsres              error
+	bsCount            int
+	InternalLookupFunc func(dhtid node.DhtID) []node.Node
+	LookupFunc         func(string) (node.Node, error)
+	lookupRes          node.Node
+	lookupErr          error
 }
 
 // SetUpdate sets the function to run on an issued update
 func (m *MockDHT) SetUpdate(f func(n node.Node)) {
-	m.update = f
+	m.UpdateFunc = f
 }
 
 // SetLookupResult sets the result ok a lookup operation
@@ -25,8 +31,8 @@ func (m *MockDHT) SetLookupResult(node node.Node, err error) {
 
 // Update is a dht update operation it updates the updatecount
 func (m *MockDHT) Update(node node.Node) {
-	if m.update != nil {
-		m.update(node)
+	if m.UpdateFunc != nil {
+		m.UpdateFunc(node)
 	}
 	m.updateCount++
 }
@@ -43,24 +49,41 @@ func (m *MockDHT) BootstrapCount() int {
 
 // Lookup is a dht lookup operation
 func (m *MockDHT) Lookup(pubkey string) (node.Node, error) {
+	if m.LookupFunc != nil {
+		return m.LookupFunc(pubkey)
+	}
 	return m.lookupRes, m.lookupErr
 }
 
+// InternalLookup is a lookup only in the local routing table
+func (m *MockDHT) InternalLookup(dhtid node.DhtID) []node.Node {
+	if m.InternalLookupFunc != nil {
+		return m.InternalLookupFunc(dhtid)
+	}
+	return nil
+}
+
 // SetBootstrap set the bootstrap result
 func (m *MockDHT) SetBootstrap(err error) {
 	m.bsres = err
 }
 
 // Bootstrap is a dht bootstrap operation function it update the bootstrap count
-func (m *MockDHT) Bootstrap() error {
+func (m *MockDHT) Bootstrap(ctx context.Context) error {
 	m.bsCount++
 	return m.bsres
 }
 
+
+// SelectPeers mocks selecting peers.
 func (m *MockDHT) SelectPeers(qty int) []node.Node {
+	if m.SelectPeersFunc != nil {
+		return m.SelectPeersFunc(qty)
+	}
 	return []node.Node{}
 }
 
+// Size returns the size of peers in the dht
 func (m *MockDHT) Size() int {
 	//todo: set size
 	return m.updateCount

p2p/dht/table_test.go

@@ -2,6 +2,7 @@ package dht
 
 import (
 	"math/rand"
+	"sync"
 	"testing"
 	"time"
 
@@ -10,7 +11,6 @@ import (
 
 	"github.com/spacemeshos/go-spacemesh/p2p/node"
 	"github.com/stretchr/testify/assert"
-	"sync"
 )
 
 func GetTestLogger(name string) *logging.Logger {
@@ -236,17 +236,14 @@ func TestRoutingTableImpl_SelectPeersDuplicates(t *testing.T) {
 
 }
 func TestRoutingTableImpl_SelectPeers_EnoughPeers(t *testing.T) {
-	const n = 500
+	const n = 100
 	const random = 5
 
 	ids := make(map[string]node.Node)
 	sids := make(map[string]RoutingTable)
 	toselect := make(map[string]struct{})
 
-	var wg sync.WaitGroup
-	var wg2 sync.WaitGroup
 
-	wg.Add(1)
 	for i := 0; i < n; i++ {
 		local := node.GenerateRandomNodeData()
 		localID := local.DhtID()
@@ -256,20 +253,26 @@ func TestRoutingTableImpl_SelectPeers_EnoughPeers(t *testing.T) {
 		ids[local.String()] = local
 		sids[local.String()] = rt
 
-		go func(l node.Node, rt RoutingTable) {
-			wg.Wait()
-			wg2.Add(1)
-			for nn := range ids {
-				if ids[nn].String() != l.String() {
-					rt.Update(ids[nn])
-				}
-			}
-			wg2.Done()
+	}
 
-		}(local, rt)
+	var wg sync.WaitGroup
+
+	for _, id := range ids {
+		id := id
+		for _, secondID := range ids {
+			if id.DhtID().Equals(secondID.DhtID()) {
+				continue
+			}
+			wg.Add(1)
+			go func(id, secondID node.Node) {
+				sids[id.String()].Update(secondID)
+				wg.Done()
+			}(id, secondID)
+		}
 	}
-	wg.Done()
-	wg2.Wait()
+
+	wg.Wait()
+
 	for rtid := range sids {
 		sel := sids[rtid].SelectPeers(random)
 		assert.NotNil(t, sel)