Kademlia refactor (#17641)

* swarm/network: simplify kademlia/hive; rid interfaces

* swarm, swarm/network/stream, swarm/netork/simulations,, swarm/pss: adapt to new Kad API

* swarm/network: minor changes re review; add missing lock to NeighbourhoodDepthC

1 files changed, 15 insertions, 56 deletions

diff --git a/swarm/network/hive.go b/swarm/network/hive.go
index 366021088..425c1d5a1 100644
--- a/swarm/network/hive.go
+++ b/swarm/network/hive.go
@@ -32,31 +32,10 @@ import (
 Hive is the logistic manager of the swarm
 
 When the hive is started, a forever loop is launched that
-asks the Overlay Topology driver (e.g., generic kademlia nodetable)
+asks the  kademlia nodetable
 to suggest peers to bootstrap connectivity
 */
 
-// Overlay is the interface for kademlia (or other topology drivers)
-type Overlay interface {
-	// suggest peers to connect to
-	SuggestPeer() (OverlayAddr, int, bool)
-	// register and deregister peer connections
-	On(OverlayConn) (depth uint8, changed bool)
-	Off(OverlayConn)
-	// register peer addresses
-	Register([]OverlayAddr) error
-	// iterate over connected peers
-	EachConn([]byte, int, func(OverlayConn, int, bool) bool)
-	// iterate over known peers (address records)
-	EachAddr([]byte, int, func(OverlayAddr, int, bool) bool)
-	// pretty print the connectivity
-	String() string
-	// base Overlay address of the node itself
-	BaseAddr() []byte
-	// connectivity health check used for testing
-	Healthy(*PeerPot) *Health
-}
-
 // HiveParams holds the config options to hive
 type HiveParams struct {
 	Discovery             bool  // if want discovery of not
@@ -78,7 +57,7 @@ func NewHiveParams() *HiveParams {
 // Hive manages network connections of the swarm node
 type Hive struct {
 	*HiveParams                      // settings
-	Overlay                          // the overlay connectiviy driver
+	*Kademlia                        // the overlay connectiviy driver
 	Store       state.Store          // storage interface to save peers across sessions
 	addPeer     func(*discover.Node) // server callback to connect to a peer
 	// bookkeeping
@@ -88,12 +67,12 @@ type Hive struct {
 
 // NewHive constructs a new hive
 // HiveParams: config parameters
-// Overlay: connectivity driver using a network topology
+// Kademlia: connectivity driver using a network topology
 // StateStore: to save peers across sessions
-func NewHive(params *HiveParams, overlay Overlay, store state.Store) *Hive {
+func NewHive(params *HiveParams, kad *Kademlia, store state.Store) *Hive {
 	return &Hive{
 		HiveParams: params,
-		Overlay:    overlay,
+		Kademlia:   kad,
 		Store:      store,
 	}
 }
@@ -133,7 +112,7 @@ func (h *Hive) Stop() error {
 		}
 	}
 	log.Info(fmt.Sprintf("%08x hive stopped, dropping peers", h.BaseAddr()[:4]))
-	h.EachConn(nil, 255, func(p OverlayConn, _ int, _ bool) bool {
+	h.EachConn(nil, 255, func(p *Peer, _ int, _ bool) bool {
 		log.Info(fmt.Sprintf("%08x dropping peer %08x", h.BaseAddr()[:4], p.Address()[:4]))
 		p.Drop(nil)
 		return true
@@ -151,14 +130,14 @@ func (h *Hive) connect() {
 
 		addr, depth, changed := h.SuggestPeer()
 		if h.Discovery && changed {
-			NotifyDepth(uint8(depth), h)
+			NotifyDepth(uint8(depth), h.Kademlia)
 		}
 		if addr == nil {
 			continue
 		}
 
 		log.Trace(fmt.Sprintf("%08x hive connect() suggested %08x", h.BaseAddr()[:4], addr.Address()[:4]))
-		under, err := discover.ParseNode(string(addr.(Addr).Under()))
+		under, err := discover.ParseNode(string(addr.Under()))
 		if err != nil {
 			log.Warn(fmt.Sprintf("%08x unable to connect to bee %08x: invalid node URL: %v", h.BaseAddr()[:4], addr.Address()[:4], err))
 			continue
@@ -170,19 +149,19 @@ func (h *Hive) connect() {
 
 // Run protocol run function
 func (h *Hive) Run(p *BzzPeer) error {
-	dp := newDiscovery(p, h)
+	dp := NewPeer(p, h.Kademlia)
 	depth, changed := h.On(dp)
 	// if we want discovery, advertise change of depth
 	if h.Discovery {
 		if changed {
 			// if depth changed, send to all peers
-			NotifyDepth(depth, h)
+			NotifyDepth(depth, h.Kademlia)
 		} else {
 			// otherwise just send depth to new peer
 			dp.NotifyDepth(depth)
 		}
 	}
-	NotifyPeer(p.Off(), h)
+	NotifyPeer(p.BzzAddr, h.Kademlia)
 	defer h.Off(dp)
 	return dp.Run(dp.HandleMsg)
 }
@@ -206,17 +185,6 @@ func (h *Hive) PeerInfo(id discover.NodeID) interface{} {
 	}
 }
 
-// ToAddr returns the serialisable version of u
-func ToAddr(pa OverlayPeer) *BzzAddr {
-	if addr, ok := pa.(*BzzAddr); ok {
-		return addr
-	}
-	if p, ok := pa.(*discPeer); ok {
-		return p.BzzAddr
-	}
-	return pa.(*BzzPeer).BzzAddr
-}
-
 // loadPeers, savePeer implement persistence callback/
 func (h *Hive) loadPeers() error {
 	var as []*BzzAddr
@@ -230,28 +198,19 @@ func (h *Hive) loadPeers() error {
 	}
 	log.Info(fmt.Sprintf("hive %08x: peers loaded", h.BaseAddr()[:4]))
 
-	return h.Register(toOverlayAddrs(as...))
-}
-
-// toOverlayAddrs transforms an array of BzzAddr to OverlayAddr
-func toOverlayAddrs(as ...*BzzAddr) (oas []OverlayAddr) {
-	for _, a := range as {
-		oas = append(oas, OverlayAddr(a))
-	}
-	return
+	return h.Register(as...)
 }
 
 // savePeers, savePeer implement persistence callback/
 func (h *Hive) savePeers() error {
 	var peers []*BzzAddr
-	h.Overlay.EachAddr(nil, 256, func(pa OverlayAddr, i int, _ bool) bool {
+	h.Kademlia.EachAddr(nil, 256, func(pa *BzzAddr, i int, _ bool) bool {
 		if pa == nil {
 			log.Warn(fmt.Sprintf("empty addr: %v", i))
 			return true
 		}
-		apa := ToAddr(pa)
-		log.Trace("saving peer", "peer", apa)
-		peers = append(peers, apa)
+		log.Trace("saving peer", "peer", pa)
+		peers = append(peers, pa)
 		return true
 	})
 	if err := h.Store.Put("peers", peers); err != nil {