p2p/simulation: move connection methods from swarm/network/simulation (#18323)

p2p/simulations/connect.go

@@ -14,65 +14,69 @@
 // You should have received a copy of the GNU Lesser General Public License
 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
 
-package simulation
+package simulations
 
 import (
+	"errors"
 	"strings"
 
 	"github.com/ethereum/go-ethereum/p2p/enode"
 )
 
+var (
+	ErrNodeNotFound = errors.New("node not found")
+	ErrNoPivotNode  = errors.New("no pivot node set")
+)
+
 // ConnectToPivotNode connects the node with provided NodeID
-// to the pivot node, already set by Simulation.SetPivotNode method.
+// to the pivot node, already set by Network.SetPivotNode method.
 // It is useful when constructing a star network topology
-// when simulation adds and removes nodes dynamically.
+// when Network adds and removes nodes dynamically.
-func (s *Simulation) ConnectToPivotNode(id enode.ID) (err error) {
+func (net *Network) ConnectToPivotNode(id enode.ID) (err error) {
-	pid := s.PivotNodeID()
+	pivot := net.GetPivotNode()
-	if pid == nil {
+	if pivot == nil {
 		return ErrNoPivotNode
 	}
-	return s.connect(*pid, id)
+	return net.connect(pivot.ID(), id)
 }
 
 // ConnectToLastNode connects the node with provided NodeID
 // to the last node that is up, and avoiding connection to self.
 // It is useful when constructing a chain network topology
-// when simulation adds and removes nodes dynamically.
+// when Network adds and removes nodes dynamically.
-func (s *Simulation) ConnectToLastNode(id enode.ID) (err error) {
+func (net *Network) ConnectToLastNode(id enode.ID) (err error) {
-	ids := s.UpNodeIDs()
+	ids := net.getUpNodeIDs()
 	l := len(ids)
 	if l < 2 {
 		return nil
 	}
-	lid := ids[l-1]
+	last := ids[l-1]
-	if lid == id {
+	if last == id {
-		lid = ids[l-2]
+		last = ids[l-2]
 	}
-	return s.connect(lid, id)
+	return net.connect(last, id)
 }
 
-// ConnectToRandomNode connects the node with provieded NodeID
+// ConnectToRandomNode connects the node with provided NodeID
 // to a random node that is up.
-func (s *Simulation) ConnectToRandomNode(id enode.ID) (err error) {
+func (net *Network) ConnectToRandomNode(id enode.ID) (err error) {
-	n := s.RandomUpNode(id)
+	selected := net.GetRandomUpNode(id)
-	if n == nil {
+	if selected == nil {
 		return ErrNodeNotFound
 	}
-	return s.connect(n.ID, id)
+	return net.connect(selected.ID(), id)
 }
 
 // ConnectNodesFull connects all nodes one to another.
 // It provides a complete connectivity in the network
 // which should be rarely needed.
-func (s *Simulation) ConnectNodesFull(ids []enode.ID) (err error) {
+func (net *Network) ConnectNodesFull(ids []enode.ID) (err error) {
 	if ids == nil {
-		ids = s.UpNodeIDs()
+		ids = net.getUpNodeIDs()
 	}
-	l := len(ids)
+	for i, lid := range ids {
-	for i := 0; i < l; i++ {
+		for _, rid := range ids[i+1:] {
-		for j := i + 1; j < l; j++ {
+			if err = net.connect(lid, rid); err != nil {
-			err = s.connect(ids[i], ids[j])
-			if err != nil {
 				return err
 			}
 		}
@@ -82,14 +86,13 @@ func (s *Simulation) ConnectNodesFull(ids []enode.ID) (err error) {
 
 // ConnectNodesChain connects all nodes in a chain topology.
 // If ids argument is nil, all nodes that are up will be connected.
-func (s *Simulation) ConnectNodesChain(ids []enode.ID) (err error) {
+func (net *Network) ConnectNodesChain(ids []enode.ID) (err error) {
 	if ids == nil {
-		ids = s.UpNodeIDs()
+		ids = net.getUpNodeIDs()
 	}
 	l := len(ids)
 	for i := 0; i < l-1; i++ {
-		err = s.connect(ids[i], ids[i+1])
+		if err := net.connect(ids[i], ids[i+1]); err != nil {
-		if err != nil {
 			return err
 		}
 	}
@@ -98,37 +101,32 @@ func (s *Simulation) ConnectNodesChain(ids []enode.ID) (err error) {
 
 // ConnectNodesRing connects all nodes in a ring topology.
 // If ids argument is nil, all nodes that are up will be connected.
-func (s *Simulation) ConnectNodesRing(ids []enode.ID) (err error) {
+func (net *Network) ConnectNodesRing(ids []enode.ID) (err error) {
 	if ids == nil {
-		ids = s.UpNodeIDs()
+		ids = net.getUpNodeIDs()
 	}
 	l := len(ids)
 	if l < 2 {
 		return nil
 	}
-	for i := 0; i < l-1; i++ {
+	if err := net.ConnectNodesChain(ids); err != nil {
-		err = s.connect(ids[i], ids[i+1])
-		if err != nil {
 		return err
 	}
-	}
+	return net.connect(ids[l-1], ids[0])
-	return s.connect(ids[l-1], ids[0])
 }
 
 // ConnectNodesStar connects all nodes in a star topology
 // with the center at provided NodeID.
 // If ids argument is nil, all nodes that are up will be connected.
-func (s *Simulation) ConnectNodesStar(id enode.ID, ids []enode.ID) (err error) {
+func (net *Network) ConnectNodesStar(pivot enode.ID, ids []enode.ID) (err error) {
 	if ids == nil {
-		ids = s.UpNodeIDs()
+		ids = net.getUpNodeIDs()
 	}
-	l := len(ids)
+	for _, id := range ids {
-	for i := 0; i < l; i++ {
+		if pivot == id {
-		if id == ids[i] {
 			continue
 		}
-		err = s.connect(id, ids[i])
+		if err := net.connect(pivot, id); err != nil {
-		if err != nil {
 			return err
 		}
 	}
@@ -138,17 +136,17 @@ func (s *Simulation) ConnectNodesStar(id enode.ID, ids []enode.ID) (err error) {
 // ConnectNodesStarPivot connects all nodes in a star topology
 // with the center at already set pivot node.
 // If ids argument is nil, all nodes that are up will be connected.
-func (s *Simulation) ConnectNodesStarPivot(ids []enode.ID) (err error) {
+func (net *Network) ConnectNodesStarPivot(ids []enode.ID) (err error) {
-	id := s.PivotNodeID()
+	pivot := net.GetPivotNode()
-	if id == nil {
+	if pivot == nil {
 		return ErrNoPivotNode
 	}
-	return s.ConnectNodesStar(*id, ids)
+	return net.ConnectNodesStar(pivot.ID(), ids)
 }
 
 // connect connects two nodes but ignores already connected error.
-func (s *Simulation) connect(oneID, otherID enode.ID) error {
+func (net *Network) connect(oneID, otherID enode.ID) error {
-	return ignoreAlreadyConnectedErr(s.Net.Connect(oneID, otherID))
+	return ignoreAlreadyConnectedErr(net.Connect(oneID, otherID))
 }
 
 func ignoreAlreadyConnectedErr(err error) error {
@@ -157,3 +155,22 @@ func ignoreAlreadyConnectedErr(err error) error {
 	}
 	return err
 }
+
+// SetPivotNode sets the NodeID of the network's pivot node.
+// Pivot node is just a specific node that should be treated
+// differently then other nodes in test. SetPivotNode and
+// GetPivotNode are just a convenient functions to set and
+// retrieve it.
+func (net *Network) SetPivotNode(id enode.ID) {
+	net.lock.Lock()
+	defer net.lock.Unlock()
+	net.pivotNodeID = id
+}
+
+// GetPivotNode returns NodeID of the pivot node set by
+// Network.SetPivotNode method.
+func (net *Network) GetPivotNode() (node *Node) {
+	net.lock.RLock()
+	defer net.lock.RUnlock()
+	return net.getNode(net.pivotNodeID)
+}

p2p/simulations/connect_test.go

@@ -0,0 +1,190 @@
+// Copyright 2018 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package simulations
+
+import (
+	"testing"
+
+	"github.com/ethereum/go-ethereum/node"
+	"github.com/ethereum/go-ethereum/p2p/enode"
+	"github.com/ethereum/go-ethereum/p2p/simulations/adapters"
+)
+
+func newTestNetwork(t *testing.T, nodeCount int) (*Network, []enode.ID) {
+	adapter := adapters.NewSimAdapter(adapters.Services{
+		"noopwoop": func(ctx *adapters.ServiceContext) (node.Service, error) {
+			return NewNoopService(nil), nil
+		},
+	})
+
+	// create network
+	network := NewNetwork(adapter, &NetworkConfig{
+		DefaultService: "noopwoop",
+	})
+
+	// create and start nodes
+	ids := make([]enode.ID, nodeCount)
+	for i := range ids {
+		conf := adapters.RandomNodeConfig()
+		node, err := network.NewNodeWithConfig(conf)
+		if err != nil {
+			t.Fatalf("error creating node: %s", err)
+		}
+		if err := network.Start(node.ID()); err != nil {
+			t.Fatalf("error starting node: %s", err)
+		}
+		ids[i] = node.ID()
+	}
+
+	if len(network.Conns) > 0 {
+		t.Fatal("no connections should exist after just adding nodes")
+	}
+
+	return network, ids
+}
+
+func TestConnectToPivotNode(t *testing.T) {
+	net, ids := newTestNetwork(t, 2)
+	defer net.Shutdown()
+
+	pivot := ids[0]
+	net.SetPivotNode(pivot)
+
+	other := ids[1]
+	err := net.ConnectToPivotNode(other)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if net.GetConn(pivot, other) == nil {
+		t.Error("pivot and the other node are not connected")
+	}
+}
+
+func TestConnectToLastNode(t *testing.T) {
+	net, ids := newTestNetwork(t, 10)
+	defer net.Shutdown()
+
+	first := ids[0]
+	if err := net.ConnectToLastNode(first); err != nil {
+		t.Fatal(err)
+	}
+
+	last := ids[len(ids)-1]
+	for i, id := range ids {
+		if id == first || id == last {
+			continue
+		}
+
+		if net.GetConn(first, id) != nil {
+			t.Errorf("connection must not exist with node(ind: %v, id: %v)", i, id)
+		}
+	}
+
+	if net.GetConn(first, last) == nil {
+		t.Error("first and last node must be connected")
+	}
+}
+
+func TestConnectToRandomNode(t *testing.T) {
+	net, ids := newTestNetwork(t, 10)
+	defer net.Shutdown()
+
+	err := net.ConnectToRandomNode(ids[0])
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var cc int
+	for i, a := range ids {
+		for _, b := range ids[i:] {
+			if net.GetConn(a, b) != nil {
+				cc++
+			}
+		}
+	}
+
+	if cc != 1 {
+		t.Errorf("expected one connection, got %v", cc)
+	}
+}
+
+func TestConnectNodesFull(t *testing.T) {
+	net, ids := newTestNetwork(t, 12)
+	defer net.Shutdown()
+
+	err := net.ConnectNodesFull(ids)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	VerifyFull(t, net, ids)
+}
+
+func TestConnectNodesChain(t *testing.T) {
+	net, ids := newTestNetwork(t, 10)
+	defer net.Shutdown()
+
+	err := net.ConnectNodesChain(ids)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	VerifyChain(t, net, ids)
+}
+
+func TestConnectNodesRing(t *testing.T) {
+	net, ids := newTestNetwork(t, 10)
+	defer net.Shutdown()
+
+	err := net.ConnectNodesRing(ids)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	VerifyRing(t, net, ids)
+}
+
+func TestConnectNodesStar(t *testing.T) {
+	net, ids := newTestNetwork(t, 10)
+	defer net.Shutdown()
+
+	pivotIndex := 2
+
+	err := net.ConnectNodesStar(ids[pivotIndex], ids)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	VerifyStar(t, net, ids, pivotIndex)
+}
+
+func TestConnectNodesStarPivot(t *testing.T) {
+	net, ids := newTestNetwork(t, 10)
+	defer net.Shutdown()
+
+	pivotIndex := 4
+
+	net.SetPivotNode(ids[pivotIndex])
+
+	err := net.ConnectNodesStarPivot(ids)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	VerifyStar(t, net, ids, pivotIndex)
+}

p2p/simulations/network.go

@@ -22,6 +22,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"math/rand"
 	"sync"
 	"time"
 
@@ -57,6 +58,8 @@ type Network struct {
 	Conns   []*Conn `json:"conns"`
 	connMap map[string]int
 
+	pivotNodeID enode.ID
+
 	nodeAdapter adapters.NodeAdapter
 	events      event.Feed
 	lock        sync.RWMutex
@@ -370,23 +373,32 @@ func (net *Network) DidReceive(sender, receiver enode.ID, proto string, code uin
 // GetNode gets the node with the given ID, returning nil if the node does not
 // exist
 func (net *Network) GetNode(id enode.ID) *Node {
-	net.lock.Lock()
+	net.lock.RLock()
-	defer net.lock.Unlock()
+	defer net.lock.RUnlock()
 	return net.getNode(id)
 }
 
 // GetNode gets the node with the given name, returning nil if the node does
 // not exist
 func (net *Network) GetNodeByName(name string) *Node {
-	net.lock.Lock()
+	net.lock.RLock()
-	defer net.lock.Unlock()
+	defer net.lock.RUnlock()
 	return net.getNodeByName(name)
 }
 
+func (net *Network) getNodeByName(name string) *Node {
+	for _, node := range net.Nodes {
+		if node.Config.Name == name {
+			return node
+		}
+	}
+	return nil
+}
+
 // GetNodes returns the existing nodes
 func (net *Network) GetNodes() (nodes []*Node) {
-	net.lock.Lock()
+	net.lock.RLock()
-	defer net.lock.Unlock()
+	defer net.lock.RUnlock()
 
 	nodes = append(nodes, net.Nodes...)
 	return nodes
@@ -400,20 +412,67 @@ func (net *Network) getNode(id enode.ID) *Node {
 	return net.Nodes[i]
 }
 
-func (net *Network) getNodeByName(name string) *Node {
+// GetRandomUpNode returns a random node on the network, which is running.
+func (net *Network) GetRandomUpNode(excludeIDs ...enode.ID) *Node {
+	net.lock.RLock()
+	defer net.lock.RUnlock()
+	return net.getRandomNode(net.getUpNodeIDs(), excludeIDs)
+}
+
+func (net *Network) getUpNodeIDs() (ids []enode.ID) {
 	for _, node := range net.Nodes {
-		if node.Config.Name == name {
+		if node.Up {
-			return node
+			ids = append(ids, node.ID())
 		}
 	}
+	return ids
+}
+
+// GetRandomDownNode returns a random node on the network, which is stopped.
+func (net *Network) GetRandomDownNode(excludeIDs ...enode.ID) *Node {
+	net.lock.RLock()
+	defer net.lock.RUnlock()
+	return net.getRandomNode(net.getDownNodeIDs(), excludeIDs)
+}
+
+func (net *Network) getDownNodeIDs() (ids []enode.ID) {
+	for _, node := range net.GetNodes() {
+		if !node.Up {
+			ids = append(ids, node.ID())
+		}
+	}
+	return ids
+}
+
+func (net *Network) getRandomNode(ids []enode.ID, excludeIDs []enode.ID) *Node {
+	filtered := filterIDs(ids, excludeIDs)
+
+	l := len(filtered)
+	if l == 0 {
 		return nil
 	}
+	return net.GetNode(filtered[rand.Intn(l)])
+}
+
+func filterIDs(ids []enode.ID, excludeIDs []enode.ID) []enode.ID {
+	exclude := make(map[enode.ID]bool)
+	for _, id := range excludeIDs {
+		exclude[id] = true
+	}
+	var filtered []enode.ID
+	for _, id := range ids {
+		if _, found := exclude[id]; !found {
+			filtered = append(filtered, id)
+		}
+	}
+	return filtered
+}
 
 // GetConn returns the connection which exists between "one" and "other"
 // regardless of which node initiated the connection
 func (net *Network) GetConn(oneID, otherID enode.ID) *Conn {
-	net.lock.Lock()
+	net.lock.RLock()
-	defer net.lock.Unlock()
+	defer net.lock.RUnlock()
 	return net.getConn(oneID, otherID)
 }
 

p2p/simulations/test.go

@@ -0,0 +1,134 @@
+package simulations
+
+import (
+	"testing"
+
+	"github.com/ethereum/go-ethereum/p2p"
+	"github.com/ethereum/go-ethereum/p2p/enode"
+	"github.com/ethereum/go-ethereum/p2p/enr"
+	"github.com/ethereum/go-ethereum/rpc"
+)
+
+// NoopService is the service that does not do anything
+// but implements node.Service interface.
+type NoopService struct {
+	c map[enode.ID]chan struct{}
+}
+
+func NewNoopService(ackC map[enode.ID]chan struct{}) *NoopService {
+	return &NoopService{
+		c: ackC,
+	}
+}
+
+func (t *NoopService) Protocols() []p2p.Protocol {
+	return []p2p.Protocol{
+		{
+			Name:    "noop",
+			Version: 666,
+			Length:  0,
+			Run: func(peer *p2p.Peer, rw p2p.MsgReadWriter) error {
+				if t.c != nil {
+					t.c[peer.ID()] = make(chan struct{})
+					close(t.c[peer.ID()])
+				}
+				rw.ReadMsg()
+				return nil
+			},
+			NodeInfo: func() interface{} {
+				return struct{}{}
+			},
+			PeerInfo: func(id enode.ID) interface{} {
+				return struct{}{}
+			},
+			Attributes: []enr.Entry{},
+		},
+	}
+}
+
+func (t *NoopService) APIs() []rpc.API {
+	return []rpc.API{}
+}
+
+func (t *NoopService) Start(server *p2p.Server) error {
+	return nil
+}
+
+func (t *NoopService) Stop() error {
+	return nil
+}
+
+func VerifyRing(t *testing.T, net *Network, ids []enode.ID) {
+	t.Helper()
+	n := len(ids)
+	for i := 0; i < n; i++ {
+		for j := i + 1; j < n; j++ {
+			c := net.GetConn(ids[i], ids[j])
+			if i == j-1 || (i == 0 && j == n-1) {
+				if c == nil {
+					t.Errorf("nodes %v and %v are not connected, but they should be", i, j)
+				}
+			} else {
+				if c != nil {
+					t.Errorf("nodes %v and %v are connected, but they should not be", i, j)
+				}
+			}
+		}
+	}
+}
+
+func VerifyChain(t *testing.T, net *Network, ids []enode.ID) {
+	t.Helper()
+	n := len(ids)
+	for i := 0; i < n; i++ {
+		for j := i + 1; j < n; j++ {
+			c := net.GetConn(ids[i], ids[j])
+			if i == j-1 {
+				if c == nil {
+					t.Errorf("nodes %v and %v are not connected, but they should be", i, j)
+				}
+			} else {
+				if c != nil {
+					t.Errorf("nodes %v and %v are connected, but they should not be", i, j)
+				}
+			}
+		}
+	}
+}
+
+func VerifyFull(t *testing.T, net *Network, ids []enode.ID) {
+	t.Helper()
+	n := len(ids)
+	var connections int
+	for i, lid := range ids {
+		for _, rid := range ids[i+1:] {
+			if net.GetConn(lid, rid) != nil {
+				connections++
+			}
+		}
+	}
+
+	want := n * (n - 1) / 2
+	if connections != want {
+		t.Errorf("wrong number of connections, got: %v, want: %v", connections, want)
+	}
+}
+
+func VerifyStar(t *testing.T, net *Network, ids []enode.ID, centerIndex int) {
+	t.Helper()
+	n := len(ids)
+	for i := 0; i < n; i++ {
+		for j := i + 1; j < n; j++ {
+			c := net.GetConn(ids[i], ids[j])
+			if i == centerIndex || j == centerIndex {
+				if c == nil {
+					t.Errorf("nodes %v and %v are not connected, but they should be", i, j)
+				}
+			} else {
+				if c != nil {
+					t.Errorf("nodes %v and %v are connected, but they should not be", i, j)
+				}
+			}
+		}
+	}
+}

swarm/network/simulation/connect_test.go

@@ -1,306 +0,0 @@
-// Copyright 2018 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package simulation
-
-import (
-	"testing"
-
-	"github.com/ethereum/go-ethereum/p2p/enode"
-)
-
-func TestConnectToPivotNode(t *testing.T) {
-	sim := New(noopServiceFuncMap)
-	defer sim.Close()
-
-	pid, err := sim.AddNode()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	sim.SetPivotNode(pid)
-
-	id, err := sim.AddNode()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if len(sim.Net.Conns) > 0 {
-		t.Fatal("no connections should exist after just adding nodes")
-	}
-
-	err = sim.ConnectToPivotNode(id)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if sim.Net.GetConn(id, pid) == nil {
-		t.Error("node did not connect to pivot node")
-	}
-}
-
-func TestConnectToLastNode(t *testing.T) {
-	sim := New(noopServiceFuncMap)
-	defer sim.Close()
-
-	n := 10
-
-	ids, err := sim.AddNodes(n)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	id, err := sim.AddNode()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if len(sim.Net.Conns) > 0 {
-		t.Fatal("no connections should exist after just adding nodes")
-	}
-
-	err = sim.ConnectToLastNode(id)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	for _, i := range ids[:n-2] {
-		if sim.Net.GetConn(id, i) != nil {
-			t.Error("node connected to the node that is not the last")
-		}
-	}
-
-	if sim.Net.GetConn(id, ids[n-1]) == nil {
-		t.Error("node did not connect to the last node")
-	}
-}
-
-func TestConnectToRandomNode(t *testing.T) {
-	sim := New(noopServiceFuncMap)
-	defer sim.Close()
-
-	n := 10
-
-	ids, err := sim.AddNodes(n)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if len(sim.Net.Conns) > 0 {
-		t.Fatal("no connections should exist after just adding nodes")
-	}
-
-	err = sim.ConnectToRandomNode(ids[0])
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	var cc int
-	for i := 0; i < n; i++ {
-		for j := i + 1; j < n; j++ {
-			if sim.Net.GetConn(ids[i], ids[j]) != nil {
-				cc++
-			}
-		}
-	}
-
-	if cc != 1 {
-		t.Errorf("expected one connection, got %v", cc)
-	}
-}
-
-func TestConnectNodesFull(t *testing.T) {
-	sim := New(noopServiceFuncMap)
-	defer sim.Close()
-
-	ids, err := sim.AddNodes(12)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if len(sim.Net.Conns) > 0 {
-		t.Fatal("no connections should exist after just adding nodes")
-	}
-
-	err = sim.ConnectNodesFull(ids)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	testFull(t, sim, ids)
-}
-
-func testFull(t *testing.T, sim *Simulation, ids []enode.ID) {
-	n := len(ids)
-	var cc int
-	for i := 0; i < n; i++ {
-		for j := i + 1; j < n; j++ {
-			if sim.Net.GetConn(ids[i], ids[j]) != nil {
-				cc++
-			}
-		}
-	}
-
-	want := n * (n - 1) / 2
-
-	if cc != want {
-		t.Errorf("expected %v connection, got %v", want, cc)
-	}
-}
-
-func TestConnectNodesChain(t *testing.T) {
-	sim := New(noopServiceFuncMap)
-	defer sim.Close()
-
-	ids, err := sim.AddNodes(10)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if len(sim.Net.Conns) > 0 {
-		t.Fatal("no connections should exist after just adding nodes")
-	}
-
-	err = sim.ConnectNodesChain(ids)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	testChain(t, sim, ids)
-}
-
-func testChain(t *testing.T, sim *Simulation, ids []enode.ID) {
-	n := len(ids)
-	for i := 0; i < n; i++ {
-		for j := i + 1; j < n; j++ {
-			c := sim.Net.GetConn(ids[i], ids[j])
-			if i == j-1 {
-				if c == nil {
-					t.Errorf("nodes %v and %v are not connected, but they should be", i, j)
-				}
-			} else {
-				if c != nil {
-					t.Errorf("nodes %v and %v are connected, but they should not be", i, j)
-				}
-			}
-		}
-	}
-}
-
-func TestConnectNodesRing(t *testing.T) {
-	sim := New(noopServiceFuncMap)
-	defer sim.Close()
-
-	ids, err := sim.AddNodes(10)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if len(sim.Net.Conns) > 0 {
-		t.Fatal("no connections should exist after just adding nodes")
-	}
-
-	err = sim.ConnectNodesRing(ids)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	testRing(t, sim, ids)
-}
-
-func testRing(t *testing.T, sim *Simulation, ids []enode.ID) {
-	n := len(ids)
-	for i := 0; i < n; i++ {
-		for j := i + 1; j < n; j++ {
-			c := sim.Net.GetConn(ids[i], ids[j])
-			if i == j-1 || (i == 0 && j == n-1) {
-				if c == nil {
-					t.Errorf("nodes %v and %v are not connected, but they should be", i, j)
-				}
-			} else {
-				if c != nil {
-					t.Errorf("nodes %v and %v are connected, but they should not be", i, j)
-				}
-			}
-		}
-	}
-}
-
-func TestConnectToNodesStar(t *testing.T) {
-	sim := New(noopServiceFuncMap)
-	defer sim.Close()
-
-	ids, err := sim.AddNodes(10)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if len(sim.Net.Conns) > 0 {
-		t.Fatal("no connections should exist after just adding nodes")
-	}
-
-	centerIndex := 2
-
-	err = sim.ConnectNodesStar(ids[centerIndex], ids)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	testStar(t, sim, ids, centerIndex)
-}
-
-func testStar(t *testing.T, sim *Simulation, ids []enode.ID, centerIndex int) {
-	n := len(ids)
-	for i := 0; i < n; i++ {
-		for j := i + 1; j < n; j++ {
-			c := sim.Net.GetConn(ids[i], ids[j])
-			if i == centerIndex || j == centerIndex {
-				if c == nil {
-					t.Errorf("nodes %v and %v are not connected, but they should be", i, j)
-				}
-			} else {
-				if c != nil {
-					t.Errorf("nodes %v and %v are connected, but they should not be", i, j)
-				}
-			}
-		}
-	}
-}
-
-func TestConnectToNodesStarPivot(t *testing.T) {
-	sim := New(noopServiceFuncMap)
-	defer sim.Close()
-
-	ids, err := sim.AddNodes(10)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if len(sim.Net.Conns) > 0 {
-		t.Fatal("no connections should exist after just adding nodes")
-	}
-
-	pivotIndex := 4
-
-	sim.SetPivotNode(ids[pivotIndex])
-
-	err = sim.ConnectNodesStarPivot(ids)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	testStar(t, sim, ids, pivotIndex)
-}

swarm/network/simulation/events_test.go

@@ -59,7 +59,7 @@ func TestPeerEvents(t *testing.T) {
 		}
 	}()
 
-	err = sim.ConnectNodesChain(sim.NodeIDs())
+	err = sim.Net.ConnectNodesChain(sim.NodeIDs())
 	if err != nil {
 		t.Fatal(err)
 	}

swarm/network/simulation/node.go

@@ -127,7 +127,7 @@ func (s *Simulation) AddNodesAndConnectFull(count int, opts ...AddNodeOption) (i
 	if err != nil {
 		return nil, err
 	}
-	err = s.ConnectNodesFull(ids)
+	err = s.Net.ConnectNodesFull(ids)
 	if err != nil {
 		return nil, err
 	}
@@ -145,7 +145,7 @@ func (s *Simulation) AddNodesAndConnectChain(count int, opts ...AddNodeOption) (
 	if err != nil {
 		return nil, err
 	}
-	err = s.ConnectToLastNode(id)
+	err = s.Net.ConnectToLastNode(id)
 	if err != nil {
 		return nil, err
 	}
@@ -154,7 +154,7 @@ func (s *Simulation) AddNodesAndConnectChain(count int, opts ...AddNodeOption) (
 		return nil, err
 	}
 	ids = append([]enode.ID{id}, ids...)
-	err = s.ConnectNodesChain(ids)
+	err = s.Net.ConnectNodesChain(ids)
 	if err != nil {
 		return nil, err
 	}
@@ -171,7 +171,7 @@ func (s *Simulation) AddNodesAndConnectRing(count int, opts ...AddNodeOption) (i
 	if err != nil {
 		return nil, err
 	}
-	err = s.ConnectNodesRing(ids)
+	err = s.Net.ConnectNodesRing(ids)
 	if err != nil {
 		return nil, err
 	}
@@ -188,7 +188,7 @@ func (s *Simulation) AddNodesAndConnectStar(count int, opts ...AddNodeOption) (i
 	if err != nil {
 		return nil, err
 	}
-	err = s.ConnectNodesStar(ids[0], ids[1:])
+	err = s.Net.ConnectNodesStar(ids[0], ids[1:])
 	if err != nil {
 		return nil, err
 	}
@@ -267,27 +267,26 @@ func (s *Simulation) StartNode(id enode.ID) (err error) {
 
 // StartRandomNode starts a random node.
 func (s *Simulation) StartRandomNode() (id enode.ID, err error) {
-	n := s.randomDownNode()
+	n := s.Net.GetRandomDownNode()
 	if n == nil {
 		return id, ErrNodeNotFound
 	}
-	return n.ID, s.Net.Start(n.ID)
+	return n.ID(), s.Net.Start(n.ID())
 }
 
 // StartRandomNodes starts random nodes.
 func (s *Simulation) StartRandomNodes(count int) (ids []enode.ID, err error) {
 	ids = make([]enode.ID, 0, count)
-	downIDs := s.DownNodeIDs()
 	for i := 0; i < count; i++ {
-		n := s.randomNode(downIDs, ids...)
+		n := s.Net.GetRandomDownNode()
 		if n == nil {
 			return nil, ErrNodeNotFound
 		}
-		err = s.Net.Start(n.ID)
+		err = s.Net.Start(n.ID())
 		if err != nil {
 			return nil, err
 		}
-		ids = append(ids, n.ID)
+		ids = append(ids, n.ID())
 	}
 	return ids, nil
 }
@@ -299,27 +298,26 @@ func (s *Simulation) StopNode(id enode.ID) (err error) {
 
 // StopRandomNode stops a random node.
 func (s *Simulation) StopRandomNode() (id enode.ID, err error) {
-	n := s.RandomUpNode()
+	n := s.Net.GetRandomUpNode()
 	if n == nil {
 		return id, ErrNodeNotFound
 	}
-	return n.ID, s.Net.Stop(n.ID)
+	return n.ID(), s.Net.Stop(n.ID())
 }
 
 // StopRandomNodes stops random nodes.
 func (s *Simulation) StopRandomNodes(count int) (ids []enode.ID, err error) {
 	ids = make([]enode.ID, 0, count)
-	upIDs := s.UpNodeIDs()
 	for i := 0; i < count; i++ {
-		n := s.randomNode(upIDs, ids...)
+		n := s.Net.GetRandomUpNode()
 		if n == nil {
 			return nil, ErrNodeNotFound
 		}
-		err = s.Net.Stop(n.ID)
+		err = s.Net.Stop(n.ID())
 		if err != nil {
 			return nil, err
 		}
-		ids = append(ids, n.ID)
+		ids = append(ids, n.ID())
 	}
 	return ids, nil
 }
@@ -328,35 +326,3 @@ func (s *Simulation) StopRandomNodes(count int) (ids []enode.ID, err error) {
 func init() {
 	rand.Seed(time.Now().UnixNano())
 }
-
-// RandomUpNode returns a random SimNode that is up.
-// Arguments are NodeIDs for nodes that should not be returned.
-func (s *Simulation) RandomUpNode(exclude ...enode.ID) *adapters.SimNode {
-	return s.randomNode(s.UpNodeIDs(), exclude...)
-}
-
-// randomDownNode returns a random SimNode that is not up.
-func (s *Simulation) randomDownNode(exclude ...enode.ID) *adapters.SimNode {
-	return s.randomNode(s.DownNodeIDs(), exclude...)
-}
-
-// randomNode returns a random SimNode from the slice of NodeIDs.
-func (s *Simulation) randomNode(ids []enode.ID, exclude ...enode.ID) *adapters.SimNode {
-	for _, e := range exclude {
-		var i int
-		for _, id := range ids {
-			if id == e {
-				ids = append(ids[:i], ids[i+1:]...)
-			} else {
-				i++
-			}
-		}
-	}
-	l := len(ids)
-	if l == 0 {
-		return nil
-	}
-	n := s.Net.GetNode(ids[rand.Intn(l)])
-	node, _ := n.Node.(*adapters.SimNode)
-	return node
-}

swarm/network/simulation/node_test.go

@@ -26,6 +26,7 @@ import (
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/node"
 	"github.com/ethereum/go-ethereum/p2p/enode"
+	"github.com/ethereum/go-ethereum/p2p/simulations"
 	"github.com/ethereum/go-ethereum/p2p/simulations/adapters"
 	"github.com/ethereum/go-ethereum/swarm/network"
 )
@@ -228,7 +229,7 @@ func TestAddNodesAndConnectFull(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	testFull(t, sim, ids)
+	simulations.VerifyFull(t, sim.Net, ids)
 }
 
 func TestAddNodesAndConnectChain(t *testing.T) {
@@ -247,7 +248,7 @@ func TestAddNodesAndConnectChain(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	testChain(t, sim, sim.UpNodeIDs())
+	simulations.VerifyChain(t, sim.Net, sim.UpNodeIDs())
 }
 
 func TestAddNodesAndConnectRing(t *testing.T) {
@@ -259,7 +260,7 @@ func TestAddNodesAndConnectRing(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	testRing(t, sim, ids)
+	simulations.VerifyRing(t, sim.Net, ids)
 }
 
 func TestAddNodesAndConnectStar(t *testing.T) {
@@ -271,7 +272,7 @@ func TestAddNodesAndConnectStar(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	testStar(t, sim, ids, 0)
+	simulations.VerifyStar(t, sim.Net, ids, 0)
 }
 
 //To test that uploading a snapshot works

swarm/network/simulation/service.go

@@ -39,7 +39,7 @@ func (s *Simulation) Service(name string, id enode.ID) node.Service {
 // RandomService returns a single Service by name on a
 // randomly chosen node that is up.
 func (s *Simulation) RandomService(name string) node.Service {
-	n := s.RandomUpNode()
+	n := s.Net.GetRandomUpNode().Node.(*adapters.SimNode)
 	if n == nil {
 		return nil
 	}

swarm/network/simulation/simulation.go

@@ -33,7 +33,6 @@ import (
 // Common errors that are returned by functions in this package.
 var (
 	ErrNodeNotFound = errors.New("node not found")
-	ErrNoPivotNode  = errors.New("no pivot node set")
 )
 
 // Simulation provides methods on network, nodes and services

swarm/network/stream/delivery_test.go

@@ -505,7 +505,8 @@ func testDeliveryFromNodes(t *testing.T, nodes, conns, chunkCount int, skipCheck
 	result := sim.Run(ctx, func(ctx context.Context, sim *simulation.Simulation) error {
 		nodeIDs := sim.UpNodeIDs()
 		//determine the pivot node to be the first node of the simulation
-		sim.SetPivotNode(nodeIDs[0])
+		pivot := nodeIDs[0]
+
 		//distribute chunks of a random file into Stores of nodes 1 to nodes
 		//we will do this by creating a file store with an underlying round-robin store:
 		//the file store will create a hash for the uploaded file, but every chunk will be
@@ -519,7 +520,7 @@ func testDeliveryFromNodes(t *testing.T, nodes, conns, chunkCount int, skipCheck
 		//...iterate the buckets...
 		for id, bucketVal := range lStores {
 			//...and remove the one which is the pivot node
-			if id == *sim.PivotNodeID() {
+			if id == pivot {
 				continue
 			}
 			//the other ones are added to the array...
@@ -547,7 +548,7 @@ func testDeliveryFromNodes(t *testing.T, nodes, conns, chunkCount int, skipCheck
 		}
 
 		//get the pivot node's filestore
-		item, ok := sim.NodeItem(*sim.PivotNodeID(), bucketKeyFileStore)
+		item, ok := sim.NodeItem(pivot, bucketKeyFileStore)
 		if !ok {
 			return fmt.Errorf("No filestore")
 		}

swarm/network/stream/snapshot_retrieval_test.go

@@ -278,13 +278,13 @@ func runRetrievalTest(chunkCount int, nodeCount int) error {
 		}
 
 		//this is the node selected for upload
-		node := sim.RandomUpNode()
+		node := sim.Net.GetRandomUpNode()
-		item, ok := sim.NodeItem(node.ID, bucketKeyStore)
+		item, ok := sim.NodeItem(node.ID(), bucketKeyStore)
 		if !ok {
 			return fmt.Errorf("No localstore")
 		}
 		lstore := item.(*storage.LocalStore)
-		conf.hashes, err = uploadFileToSingleNodeStore(node.ID, chunkCount, lstore)
+		conf.hashes, err = uploadFileToSingleNodeStore(node.ID(), chunkCount, lstore)
 		if err != nil {
 			return err
 		}

swarm/network/stream/snapshot_sync_test.go

@@ -248,20 +248,20 @@ func runSim(conf *synctestConfig, ctx context.Context, sim *simulation.Simulatio
 
 		//get the node at that index
 		//this is the node selected for upload
-		node := sim.RandomUpNode()
+		node := sim.Net.GetRandomUpNode()
-		item, ok := sim.NodeItem(node.ID, bucketKeyStore)
+		item, ok := sim.NodeItem(node.ID(), bucketKeyStore)
 		if !ok {
 			return fmt.Errorf("No localstore")
 		}
 		lstore := item.(*storage.LocalStore)
-		hashes, err := uploadFileToSingleNodeStore(node.ID, chunkCount, lstore)
+		hashes, err := uploadFileToSingleNodeStore(node.ID(), chunkCount, lstore)
 		if err != nil {
 			return err
 		}
 		for _, h := range hashes {
 			evt := &simulations.Event{
 				Type: EventTypeChunkCreated,
-				Node: sim.Net.GetNode(node.ID),
+				Node: sim.Net.GetNode(node.ID()),
 				Data: h.String(),
 			}
 			sim.Net.Events().Send(evt)
@@ -453,13 +453,13 @@ func testSyncingViaDirectSubscribe(t *testing.T, chunkCount int, nodeCount int)
 			}
 		}
 		//select a random node for upload
-		node := sim.RandomUpNode()
+		node := sim.Net.GetRandomUpNode()
-		item, ok := sim.NodeItem(node.ID, bucketKeyStore)
+		item, ok := sim.NodeItem(node.ID(), bucketKeyStore)
 		if !ok {
 			return fmt.Errorf("No localstore")
 		}
 		lstore := item.(*storage.LocalStore)
-		hashes, err := uploadFileToSingleNodeStore(node.ID, chunkCount, lstore)
+		hashes, err := uploadFileToSingleNodeStore(node.ID(), chunkCount, lstore)
 		if err != nil {
 			return err
 		}

swarm/network/stream/visualized_snapshot_sync_sim_test.go

@@ -103,7 +103,7 @@ func TestNonExistingHashesWithServer(t *testing.T) {
 
 	result := sim.Run(ctx, func(ctx context.Context, sim *simulation.Simulation) error {
 		//check on the node's FileStore (netstore)
-		id := sim.RandomUpNode().ID
+		id := sim.Net.GetRandomUpNode().ID()
 		item, ok := sim.NodeItem(id, bucketKeyFileStore)
 		if !ok {
 			t.Fatalf("No filestore")