swarm/network: minor change to tests and no pss in bzz proto

swarm/network/discovery_test.go

@@ -25,7 +25,7 @@ func TestDiscovery(t *testing.T) {
 		return p.Run(dp.HandleMsg)
 	}
 
-	s := newBzzBaseTester(t, 1, addr, DiscoveryProtocol, run)
+	s := newBzzBaseTester(t, 1, addr, DiscoverySpec, run)
 	defer s.Stop()
 
 	s.TestExchanges(p2ptest.Exchange{

swarm/network/hive_test.go

@@ -37,7 +37,7 @@ func newHiveTester(t *testing.T, params *HiveParams) (*bzzTester, *Hive) {
 	to := NewKademlia(addr.OAddr, NewKadParams())
 	pp := NewHive(params, to, nil) // hive
 
-	return newBzzBaseTester(t, 1, addr, DiscoveryProtocol, pp.Run), pp
+	return newBzzBaseTester(t, 1, addr, DiscoverySpec, pp.Run), pp
 }
 
 func TestRegisterAndConnect(t *testing.T) {

swarm/network/protocol.go

@@ -20,7 +20,6 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"net"
 	"sync"
 	"time"
 
@@ -38,7 +37,7 @@ const (
 	ProtocolMaxMsgSize = 10 * 1024 * 1024
 )
 
-var BzzProtocol = &protocols.Spec{
+var BzzHandshakeSpec = &protocols.Spec{
 	Name:       "bzz",
 	Version:    1,
 	MaxMsgSize: 10 * 1024 * 1024,
@@ -47,7 +46,7 @@ var BzzProtocol = &protocols.Spec{
 	},
 }
 
-var DiscoveryProtocol = &protocols.Spec{
+var DiscoverySpec = &protocols.Spec{
 	Name:       "hive",
 	Version:    1,
 	MaxMsgSize: 10 * 1024 * 1024,
@@ -58,15 +57,6 @@ var DiscoveryProtocol = &protocols.Spec{
 	},
 }
 
-var PssProtocol = &protocols.Spec{
-	Name:       "pss",
-	Version:    1,
-	MaxMsgSize: 10 * 1024 * 1024,
-	Messages: []interface{}{
-		PssMsg{},
-	},
-}
-
 // the Addr interface that peerPool needs
 type Addr interface {
 	OverlayPeer
@@ -98,75 +88,54 @@ type Store interface {
 	Save(string, []byte) error
 }
 
+// BzzConfig captures the config params used by the hive
 type BzzConfig struct {
 	OverlayAddr  []byte
 	UnderlayAddr []byte
-
+	HiveParams   *HiveParams
-	KadParams  *KadParams
-	HiveParams *HiveParams
-	PssParams  *PssParams
-
-	Store Store
 }
 
 // Bzz is the swarm protocol bundle
 type Bzz struct {
-	Kademlia *Kademlia
+	Hive       *Hive
-	Hive     *Hive
-	Pss      *Pss
-
 	localAddr  *bzzAddr
 	mtx        sync.Mutex
 	handshakes map[discover.NodeID]*bzzHandshake
 }
 
 // NewBzz is the swarm protocol constructor
-func NewBzz(config *BzzConfig) *Bzz {
+func NewBzz(config *BzzConfig, kad Overlay, store Store) *Bzz {
-	kademlia := NewKademlia(config.OverlayAddr, config.KadParams)
+	return &Bzz{
-	bzz := &Bzz{
+		Hive:       NewHive(config.HiveParams, kad, store),
-		Kademlia:   kademlia,
-		Hive:       NewHive(config.HiveParams, kademlia, config.Store),
 		localAddr:  &bzzAddr{config.OverlayAddr, config.UnderlayAddr},
 		handshakes: make(map[discover.NodeID]*bzzHandshake),
 	}
-	if config.PssParams != nil {
-		bzz.Pss = NewPss(kademlia, config.PssParams)
-	}
-	return bzz
 }
 
 // Bzz implements the node.Service interface, offers Protocols
 // * handshake/hive
 // * discovery
-// * pss
 func (b *Bzz) Protocols() []p2p.Protocol {
 	return []p2p.Protocol{
 		{
-			Name:    BzzProtocol.Name,
+			Name:    BzzHandshakeSpec.Name,
-			Version: BzzProtocol.Version,
+			Version: BzzHandshakeSpec.Version,
-			Length:  BzzProtocol.Length(),
+			Length:  BzzHandshakeSpec.Length(),
 			Run:     b.runHandshake,
 		},
 		{
-			Name:     DiscoveryProtocol.Name,
+			Name:     DiscoverySpec.Name,
-			Version:  DiscoveryProtocol.Version,
+			Version:  DiscoverySpec.Version,
-			Length:   DiscoveryProtocol.Length(),
+			Length:   DiscoverySpec.Length(),
-			Run:      b.runProtocol(DiscoveryProtocol, b.Hive.Run),
+			Run:      b.runProtocol(DiscoverySpec, b.Hive.Run),
 			NodeInfo: b.Hive.NodeInfo,
 			PeerInfo: b.Hive.PeerInfo,
 		},
-		{
-			Name:    PssProtocol.Name,
-			Version: PssProtocol.Version,
-			Length:  PssProtocol.Length(),
-			Run:     b.runProtocol(PssProtocol, b.Pss.Run),
-		},
 	}
 }
 
 // Bzz implements the node.Service interface, offers APIs:
 // * hive
-// * pss
 func (b *Bzz) APIs() []rpc.API {
 	return []rpc.API{{
 		Namespace: "hive",
@@ -232,7 +201,7 @@ func (b *Bzz) getHandshake(peerID discover.NodeID) *bzzHandshake {
 	handshake, ok := b.handshakes[peerID]
 	if !ok {
 		handshake = &bzzHandshake{
-			Version:   uint64(BzzProtocol.Version),
+			Version:   uint64(BzzHandshakeSpec.Version),
 			NetworkId: uint64(NetworkId),
 			Addr:      b.localAddr,
 			done:      make(chan struct{}),
@@ -298,7 +267,7 @@ func (self *bzzHandshake) Perform(p *p2p.Peer, rw p2p.MsgReadWriter) (err error)
 		self.err = err
 		close(self.done)
 	}()
-	peer := protocols.NewPeer(p, rw, BzzProtocol)
+	peer := protocols.NewPeer(p, rw, BzzHandshakeSpec)
 	ctx, cancel := context.WithTimeout(context.Background(), bzzHandshakeTimeout)
 	defer cancel()
 	hs, err := peer.Handshake(ctx, self)
@@ -378,8 +347,5 @@ func NewNodeIdFromAddr(addr Addr) *adapters.NodeId {
 // the overlay address is derived as the hash of the nodeId
 func NewAddrFromNodeId(n *adapters.NodeId) *bzzAddr {
 	id := n.NodeID
-	return &bzzAddr{
+	return &bzzAddr{crypto.Keccak256(id[:]), id[:]}
-		OAddr: crypto.Keccak256(id[:]),
-		UAddr: []byte(discover.NewNode(id, net.IP{127, 0, 0, 1}, 30303, 30303).String()),
-	}
 }

swarm/network/simulations/discovery/discovery_test.go

@@ -179,21 +179,23 @@ func triggerChecks(trigger chan *adapters.NodeId, net *simulations.Network, id *
 func newService(id *adapters.NodeId, snapshot []byte) node.Service {
 	addr := network.NewAddrFromNodeId(id)
 
+	kp := network.NewKadParams()
+	kp.MinProxBinSize = 2
+	kp.MaxBinSize = 3
+	kp.MinBinSize = 1
+	kp.MaxRetries = 1000
+	kp.RetryExponent = 2
+	kp.RetryInterval = 1000000
+	kad := network.NewKademlia(addr.Over(), kp)
+
+	hp := network.NewHiveParams()
+	hp.KeepAliveInterval = time.Second
+
 	config := &network.BzzConfig{
 		OverlayAddr:  addr.Over(),
 		UnderlayAddr: addr.Under(),
-		KadParams:    network.NewKadParams(),
+		HiveParams:   hp,
-		HiveParams:   network.NewHiveParams(),
 	}
 
-	config.KadParams.MinProxBinSize = 2
+	return network.NewBzz(config, kad, nil)
-	config.KadParams.MaxBinSize = 3
-	config.KadParams.MinBinSize = 1
-	config.KadParams.MaxRetries = 1000
-	config.KadParams.RetryExponent = 2
-	config.KadParams.RetryInterval = 1000000
-
-	config.HiveParams.KeepAliveInterval = time.Second
-
-	return network.NewBzz(config)
 }

swarm/network/simulations/overlay.go

@@ -62,25 +62,26 @@ func (s *Simulation) NewService(id *adapters.NodeId, snapshot []byte) node.Servi
 	s.mtx.Unlock()
 
 	addr := network.NewAddrFromNodeId(id)
-	kp := network.NewKadParams()
 
+	kp := network.NewKadParams()
 	kp.MinProxBinSize = 2
 	kp.MaxBinSize = 3
 	kp.MinBinSize = 1
 	kp.MaxRetries = 1000
 	kp.RetryExponent = 2
 	kp.RetryInterval = 1000000
+	kad := network.NewKademlia(addr.Over(), kp)
 
 	hp := network.NewHiveParams()
-	hp.KeepAliveInterval = 5 * time.Second
+	hp.KeepAliveInterval = 3 * time.Second
+
 	config := &network.BzzConfig{
 		OverlayAddr:  addr.Over(),
 		UnderlayAddr: addr.Under(),
-		KadParams:    kp,
 		HiveParams:   hp,
-		Store:        store,
 	}
-	return network.NewBzz(config)
+
+	return network.NewBzz(config, kad, store)
 }
 
 func createMockers() map[string]*simulations.MockerConfig {
@@ -112,7 +113,7 @@ func setupMocker(net *simulations.Network) []*adapters.NodeId {
 	conf := net.Config()
 	conf.DefaultService = "overlay"
 
-	nodeCount := 30
+	nodeCount := 50
 	ids := make([]*adapters.NodeId, nodeCount)
 	for i := 0; i < nodeCount; i++ {
 		node, err := net.NewNode()