swarm: network simulation for swarm tests (#769)

* cmd/swarm: minor cli flag text adjustments

* cmd/swarm, swarm/storage, swarm: fix  mingw on windows test issues

* cmd/swarm: support for smoke tests on the production swarm cluster

* cmd/swarm/swarm-smoke: simplify cluster logic as per suggestion

* changed colour of landing page

* landing page reacts to enter keypress

* swarm/api/http: sticky footer for swarm landing page using flex

* swarm/api/http: sticky footer for error pages and fix for multiple choices

* swarm: propagate ctx to internal apis (#754)

* swarm/simnet: add basic node/service functions

* swarm/netsim: add buckets for global state and kademlia health check

* swarm/netsim: Use sync.Map as bucket and provide cleanup function for...

* swarm, swarm/netsim: adjust SwarmNetworkTest

* swarm/netsim: fix tests

* swarm: added visualization option to sim net redesign

* swarm/netsim: support multiple services per node

* swarm/netsim: remove redundant return statement

* swarm/netsim: add comments

* swarm: shutdown HTTP in Simulation.Close

* swarm: sim HTTP server timeout

* swarm/netsim: add more simulation methods and peer events examples

* swarm/netsim: add WaitKademlia example

* swarm/netsim: fix comments

* swarm/netsim: terminate peer events goroutines on simulation done

* swarm, swarm/netsim: naming updates

* swarm/netsim: return not healthy kademlias on WaitTillHealthy

* swarm: fix WaitTillHealthy call in testSwarmNetwork

* swarm/netsim: allow bucket to have any type for a key

* swarm: Added snapshots to new netsim

* swarm/netsim: add more tests for bucket

* swarm/netsim: move http related things into separate files

* swarm/netsim: add AddNodeWithService option

* swarm/netsim: add more tests and Start* methods

* swarm/netsim: add peer events and kademlia tests

* swarm/netsim: fix some tests flakiness

* swarm/netsim: improve random nodes selection, fix TestStartStop* tests

* swarm/netsim: remove time measurement from TestClose to avoid flakiness

* swarm/netsim: builder pattern for netsim HTTP server (#773)

* swarm/netsim: add connect related tests

* swarm/netsim: add comment for TestPeerEvents

* swarm: rename netsim package to network/simulation

p2p/simulations/adapters/inproc.go

@@ -296,6 +296,13 @@ func (sn *SimNode) Stop() error {
 	return sn.node.Stop()
 }
 
+// Service returns a running service by name
+func (sn *SimNode) Service(name string) node.Service {
+	sn.lock.RLock()
+	defer sn.lock.RUnlock()
+	return sn.running[name]
+}
+
 // Services returns a copy of the underlying services
 func (sn *SimNode) Services() []node.Service {
 	sn.lock.RLock()
@@ -307,6 +314,17 @@ func (sn *SimNode) Services() []node.Service {
 	return services
 }
 
+// ServiceMap returns a map by names of the underlying services
+func (sn *SimNode) ServiceMap() map[string]node.Service {
+	sn.lock.RLock()
+	defer sn.lock.RUnlock()
+	services := make(map[string]node.Service, len(sn.running))
+	for name, service := range sn.running {
+		services[name] = service
+	}
+	return services
+}
+
 // Server returns the underlying p2p.Server
 func (sn *SimNode) Server() *p2p.Server {
 	return sn.node.Server()

swarm/network/simulation/bucket.go

+// 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 (
+	"github.com/ethereum/go-ethereum/p2p/discover"
+)
+
+// BucketKey is the type that should be used for keys in simulation buckets.
+type BucketKey string
+
+// NodeItem returns an item set in ServiceFunc function for a particualar node.
+func (s *Simulation) NodeItem(id discover.NodeID, key interface{}) (value interface{}, ok bool) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	if _, ok := s.buckets[id]; !ok {
+		return nil, false
+	}
+	return s.buckets[id].Load(key)
+}
+
+// SetNodeItem sets a new item associated with the node with provided NodeID.
+// Buckets should be used to avoid managing separate simulation global state.
+func (s *Simulation) SetNodeItem(id discover.NodeID, key interface{}, value interface{}) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	s.buckets[id].Store(key, value)
+}
+
+// NodeItems returns a map of items from all nodes that are all set under the
+// same BucketKey.
+func (s *Simulation) NodesItems(key interface{}) (values map[discover.NodeID]interface{}) {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+
+	ids := s.NodeIDs()
+	values = make(map[discover.NodeID]interface{}, len(ids))
+	for _, id := range ids {
+		if _, ok := s.buckets[id]; !ok {
+			continue
+		}
+		if v, ok := s.buckets[id].Load(key); ok {
+			values[id] = v
+		}
+	}
+	return values
+}
+
+// UpNodesItems returns a map of items with the same BucketKey from all nodes that are up.
+func (s *Simulation) UpNodesItems(key interface{}) (values map[discover.NodeID]interface{}) {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+
+	ids := s.UpNodeIDs()
+	values = make(map[discover.NodeID]interface{})
+	for _, id := range ids {
+		if _, ok := s.buckets[id]; !ok {
+			continue
+		}
+		if v, ok := s.buckets[id].Load(key); ok {
+			values[id] = v
+		}
+	}
+	return values
+}

swarm/network/simulation/bucket_test.go

+// 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 (
+	"sync"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/node"
+	"github.com/ethereum/go-ethereum/p2p/simulations/adapters"
+)
+
+// TestServiceBucket tests all bucket functionalities using subtests.
+// It constructs a simulation of two nodes by adding items to their buckets
+// in ServiceFunc constructor, then by SetNodeItem. Testing UpNodesItems
+// is done by stopping one node and validating availability of its items.
+func TestServiceBucket(t *testing.T) {
+	testKey := "Key"
+	testValue := "Value"
+
+	sim := New(map[string]ServiceFunc{
+		"noop": func(ctx *adapters.ServiceContext, b *sync.Map) (node.Service, func(), error) {
+			b.Store(testKey, testValue+ctx.Config.ID.String())
+			return newNoopService(), nil, nil
+		},
+	})
+	defer sim.Close()
+
+	id1, err := sim.AddNode()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	id2, err := sim.AddNode()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	t.Run("ServiceFunc bucket Store", func(t *testing.T) {
+		v, ok := sim.NodeItem(id1, testKey)
+		if !ok {
+			t.Fatal("bucket item not found")
+		}
+		s, ok := v.(string)
+		if !ok {
+			t.Fatal("bucket item value is not string")
+		}
+		if s != testValue+id1.String() {
+			t.Fatalf("expected %q, got %q", testValue+id1.String(), s)
+		}
+
+		v, ok = sim.NodeItem(id2, testKey)
+		if !ok {
+			t.Fatal("bucket item not found")
+		}
+		s, ok = v.(string)
+		if !ok {
+			t.Fatal("bucket item value is not string")
+		}
+		if s != testValue+id2.String() {
+			t.Fatalf("expected %q, got %q", testValue+id2.String(), s)
+		}
+	})
+
+	customKey := "anotherKey"
+	customValue := "anotherValue"
+
+	t.Run("SetNodeItem", func(t *testing.T) {
+		sim.SetNodeItem(id1, customKey, customValue)
+
+		v, ok := sim.NodeItem(id1, customKey)
+		if !ok {
+			t.Fatal("bucket item not found")
+		}
+		s, ok := v.(string)
+		if !ok {
+			t.Fatal("bucket item value is not string")
+		}
+		if s != customValue {
+			t.Fatalf("expected %q, got %q", customValue, s)
+		}
+
+		v, ok = sim.NodeItem(id2, customKey)
+		if ok {
+			t.Fatal("bucket item should not be found")
+		}
+	})
+
+	if err := sim.StopNode(id2); err != nil {
+		t.Fatal(err)
+	}
+
+	t.Run("UpNodesItems", func(t *testing.T) {
+		items := sim.UpNodesItems(testKey)
+
+		v, ok := items[id1]
+		if !ok {
+			t.Errorf("node 1 item not found")
+		}
+		s, ok := v.(string)
+		if !ok {
+			t.Fatal("node 1 item value is not string")
+		}
+		if s != testValue+id1.String() {
+			t.Fatalf("expected %q, got %q", testValue+id1.String(), s)
+		}
+
+		v, ok = items[id2]
+		if ok {
+			t.Errorf("node 2 item should not be found")
+		}
+	})
+
+	t.Run("NodeItems", func(t *testing.T) {
+		items := sim.NodesItems(testKey)
+
+		v, ok := items[id1]
+		if !ok {
+			t.Errorf("node 1 item not found")
+		}
+		s, ok := v.(string)
+		if !ok {
+			t.Fatal("node 1 item value is not string")
+		}
+		if s != testValue+id1.String() {
+			t.Fatalf("expected %q, got %q", testValue+id1.String(), s)
+		}
+
+		v, ok = items[id2]
+		if !ok {
+			t.Errorf("node 2 item not found")
+		}
+		s, ok = v.(string)
+		if !ok {
+			t.Fatal("node 1 item value is not string")
+		}
+		if s != testValue+id2.String() {
+			t.Fatalf("expected %q, got %q", testValue+id2.String(), s)
+		}
+	})
+}

swarm/network/simulation/connect.go

+// 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 (
+	"strings"
+
+	"github.com/ethereum/go-ethereum/p2p/discover"
+)
+
+// ConnectToPivotNode connects the node with provided NodeID
+// to the pivot node, already set by Simulation.SetPivotNode method.
+// It is useful when constructing a star network topology
+// when simulation adds and removes nodes dynamically.
+func (s *Simulation) ConnectToPivotNode(id discover.NodeID) (err error) {
+	pid := s.PivotNodeID()
+	if pid == nil {
+		return ErrNoPivotNode
+	}
+	return s.connect(*pid, 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.
+func (s *Simulation) ConnectToLastNode(id discover.NodeID) (err error) {
+	ids := s.UpNodeIDs()
+	l := len(ids)
+	if l < 2 {
+		return nil
+	}
+	lid := ids[l-1]
+	if lid == id {
+		lid = ids[l-2]
+	}
+	return s.connect(lid, id)
+}
+
+// ConnectToRandomNode connects the node with provieded NodeID
+// to a random node that is up.
+func (s *Simulation) ConnectToRandomNode(id discover.NodeID) (err error) {
+	n := s.randomUpNode(id)
+	if n == nil {
+		return ErrNodeNotFound
+	}
+	return s.connect(n.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 []discover.NodeID) (err error) {
+	if ids == nil {
+		ids = s.UpNodeIDs()
+	}
+	l := len(ids)
+	for i := 0; i < l; i++ {
+		for j := i + 1; j < l; j++ {
+			err = s.connect(ids[i], ids[j])
+			if err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+// 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 []discover.NodeID) (err error) {
+	if ids == nil {
+		ids = s.UpNodeIDs()
+	}
+	l := len(ids)
+	for i := 0; i < l-1; i++ {
+		err = s.connect(ids[i], ids[i+1])
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// 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 []discover.NodeID) (err error) {
+	if ids == nil {
+		ids = s.UpNodeIDs()
+	}
+	l := len(ids)
+	if l < 2 {
+		return nil
+	}
+	for i := 0; i < l-1; i++ {
+		err = s.connect(ids[i], ids[i+1])
+		if err != nil {
+			return err
+		}
+	}
+	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 discover.NodeID, ids []discover.NodeID) (err error) {
+	if ids == nil {
+		ids = s.UpNodeIDs()
+	}
+	l := len(ids)
+	for i := 0; i < l; i++ {
+		if id == ids[i] {
+			continue
+		}
+		err = s.connect(id, ids[i])
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// ConnectNodesStar 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 []discover.NodeID) (err error) {
+	id := s.PivotNodeID()
+	if id == nil {
+		return ErrNoPivotNode
+	}
+	return s.ConnectNodesStar(*id, ids)
+}
+
+// connect connects two nodes but ignores already connected error.
+func (s *Simulation) connect(oneID, otherID discover.NodeID) error {
+	return ignoreAlreadyConnectedErr(s.Net.Connect(oneID, otherID))
+}
+
+func ignoreAlreadyConnectedErr(err error) error {
+	if err == nil || strings.Contains(err.Error(), "already connected") {
+		return nil
+	}
+	return err
+}

swarm/network/simulation/connect_test.go

+// 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/discover"
+)
+
+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 []discover.NodeID) {
+	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 []discover.NodeID) {
+	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 []discover.NodeID) {
+	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 []discover.NodeID, 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.go

+// 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 (
+	"context"
+
+	"github.com/ethereum/go-ethereum/p2p/discover"
+
+	"github.com/ethereum/go-ethereum/p2p"
+)
+
+// PeerEvent is the type of the channel returned by Simulation.PeerEvents.
+type PeerEvent struct {
+	// NodeID is the ID of node that the event is caught on.
+	NodeID discover.NodeID
+	// Event is the event that is caught.
+	Event *p2p.PeerEvent
+	// Error is the error that may have happened during event watching.
+	Error error
+}
+
+// PeerEventsFilter defines a filter on PeerEvents to exclude messages with
+// defined properties. Use PeerEventsFilter methods to set required options.
+type PeerEventsFilter struct {
+	t        *p2p.PeerEventType
+	protocol *string
+	msgCode  *uint64
+}
+
+// NewPeerEventsFilter returns a new PeerEventsFilter instance.
+func NewPeerEventsFilter() *PeerEventsFilter {
+	return &PeerEventsFilter{}
+}
+
+// Type sets the filter to only one peer event type.
+func (f *PeerEventsFilter) Type(t p2p.PeerEventType) *PeerEventsFilter {
+	f.t = &t
+	return f
+}
+
+// Protocol sets the filter to only one message protocol.
+func (f *PeerEventsFilter) Protocol(p string) *PeerEventsFilter {
+	f.protocol = &p
+	return f
+}
+
+// MsgCode sets the filter to only one msg code.
+func (f *PeerEventsFilter) MsgCode(c uint64) *PeerEventsFilter {
+	f.msgCode = &c
+	return f
+}
+
+// PeerEvents returns a channel of events that are captured by admin peerEvents
+// subscription nodes with provided NodeIDs. Additional filters can be set to ignore
+// events that are not relevant.
+func (s *Simulation) PeerEvents(ctx context.Context, ids []discover.NodeID, filters ...*PeerEventsFilter) <-chan PeerEvent {
+	eventC := make(chan PeerEvent)
+
+	for _, id := range ids {
+		s.shutdownWG.Add(1)
+		go func(id discover.NodeID) {
+			defer s.shutdownWG.Done()
+
+			client, err := s.Net.GetNode(id).Client()
+			if err != nil {
+				eventC <- PeerEvent{NodeID: id, Error: err}
+				return
+			}
+			events := make(chan *p2p.PeerEvent)
+			sub, err := client.Subscribe(ctx, "admin", events, "peerEvents")
+			if err != nil {
+				eventC <- PeerEvent{NodeID: id, Error: err}
+				return
+			}
+			defer sub.Unsubscribe()
+
+			for {
+				select {
+				case <-ctx.Done():
+					if err := ctx.Err(); err != nil {
+						select {
+						case eventC <- PeerEvent{NodeID: id, Error: err}:
+						case <-s.Done():
+						}
+					}
+					return
+				case <-s.Done():
+					return
+				case e := <-events:
+					match := len(filters) == 0 // if there are no filters match all events
+					for _, f := range filters {
+						if f.t != nil && *f.t != e.Type {
+							continue
+						}
+						if f.protocol != nil && *f.protocol != e.Protocol {
+							continue
+						}
+						if f.msgCode != nil && e.MsgCode != nil && *f.msgCode != *e.MsgCode {
+							continue
+						}
+						// all filter parameters matched, break the loop
+						match = true
+						break
+					}
+					if match {
+						select {
+						case eventC <- PeerEvent{NodeID: id, Event: e}:
+						case <-ctx.Done():
+							if err := ctx.Err(); err != nil {
+								select {
+								case eventC <- PeerEvent{NodeID: id, Error: err}:
+								case <-s.Done():
+								}
+							}
+							return
+						case <-s.Done():
+							return
+						}
+					}
+				case err := <-sub.Err():
+					if err != nil {
+						select {
+						case eventC <- PeerEvent{NodeID: id, Error: err}:
+						case <-ctx.Done():
+							if err := ctx.Err(); err != nil {
+								select {
+								case eventC <- PeerEvent{NodeID: id, Error: err}:
+								case <-s.Done():
+								}
+							}
+							return
+						case <-s.Done():
+							return
+						}
+					}
+				}
+			}
+		}(id)
+	}
+
+	return eventC
+}

swarm/network/simulation/events_test.go

+// 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 (
+	"context"
+	"sync"
+	"testing"
+	"time"
+)
+
+// TestPeerEvents creates simulation, adds two nodes,
+// register for peer events, connects nodes in a chain
+// and waits for the number of connection events to
+// be received.
+func TestPeerEvents(t *testing.T) {
+	sim := New(noopServiceFuncMap)
+	defer sim.Close()
+
+	_, err := sim.AddNodes(2)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	events := sim.PeerEvents(ctx, sim.NodeIDs())
+
+	// two nodes -> two connection events
+	expectedEventCount := 2
+
+	var wg sync.WaitGroup
+	wg.Add(expectedEventCount)
+
+	go func() {
+		for e := range events {
+			if e.Error != nil {
+				if e.Error == context.Canceled {
+					return
+				}
+				t.Error(e.Error)
+				continue
+			}
+			wg.Done()
+		}
+	}()
+
+	err = sim.ConnectNodesChain(sim.NodeIDs())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	wg.Wait()
+}
+
+func TestPeerEventsTimeout(t *testing.T) {
+	sim := New(noopServiceFuncMap)
+	defer sim.Close()
+
+	_, err := sim.AddNodes(2)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
+	defer cancel()
+	events := sim.PeerEvents(ctx, sim.NodeIDs())
+
+	done := make(chan struct{})
+	go func() {
+		for e := range events {
+			if e.Error == context.Canceled {
+				return
+			}
+			if e.Error == context.DeadlineExceeded {
+				close(done)
+				return
+			} else {
+				t.Fatal(e.Error)
+			}
+		}
+	}()
+
+	select {
+	case <-time.After(time.Second):
+		t.Error("no context deadline received")
+	case <-done:
+		// all good, context deadline detected
+	}
+}

swarm/network/simulation/example_test.go

+// 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_test
+
+import (
+	"context"
+	"fmt"
+	"sync"
+	"time"
+
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/node"
+	"github.com/ethereum/go-ethereum/p2p"
+	"github.com/ethereum/go-ethereum/p2p/simulations/adapters"
+	"github.com/ethereum/go-ethereum/swarm/network"
+	"github.com/ethereum/go-ethereum/swarm/network/simulation"
+)
+
+// Every node can have a Kademlia associated using the node bucket under
+// BucketKeyKademlia key. This allows to use WaitTillHealthy to block until
+// all nodes have the their Kadmlias healthy.
+func ExampleSimulation_WaitTillHealthy() {
+	sim := simulation.New(map[string]simulation.ServiceFunc{
+		"bzz": func(ctx *adapters.ServiceContext, b *sync.Map) (node.Service, func(), error) {
+			addr := network.NewAddrFromNodeID(ctx.Config.ID)
+			hp := network.NewHiveParams()
+			hp.Discovery = false
+			config := &network.BzzConfig{
+				OverlayAddr:  addr.Over(),
+				UnderlayAddr: addr.Under(),
+				HiveParams:   hp,
+			}
+			kad := network.NewKademlia(addr.Over(), network.NewKadParams())
+			// store kademlia in node's bucket under BucketKeyKademlia
+			// so that it can be found by WaitTillHealthy method.
+			b.Store(simulation.BucketKeyKademlia, kad)
+			return network.NewBzz(config, kad, nil, nil, nil), nil, nil
+		},
+	})
+	defer sim.Close()
+
+	_, err := sim.AddNodesAndConnectRing(10)
+	if err != nil {
+		// handle error properly...
+		panic(err)
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
+	defer cancel()
+	ill, err := sim.WaitTillHealthy(ctx, 2)
+	if err != nil {
+		// inspect the latest detected not healthy kademlias
+		for id, kad := range ill {
+			fmt.Println("Node", id)
+			fmt.Println(kad.String())
+		}
+		// handle error...
+	}
+
+	// continue with the test
+}
+
+// Watch all peer events in the simulation network, buy receiving from a channel.
+func ExampleSimulation_PeerEvents() {
+	sim := simulation.New(nil)
+	defer sim.Close()
+
+	events := sim.PeerEvents(context.Background(), sim.NodeIDs())
+
+	go func() {
+		for e := range events {
+			if e.Error != nil {
+				log.Error("peer event", "err", e.Error)
+				continue
+			}
+			log.Info("peer event", "node", e.NodeID, "peer", e.Event.Peer, "msgcode", e.Event.MsgCode)
+		}
+	}()
+}
+
+// Detect when a nodes drop a peer.
+func ExampleSimulation_PeerEvents_disconnections() {
+	sim := simulation.New(nil)
+	defer sim.Close()
+
+	disconnections := sim.PeerEvents(
+		context.Background(),
+		sim.NodeIDs(),
+		simulation.NewPeerEventsFilter().Type(p2p.PeerEventTypeDrop),
+	)
+
+	go func() {
+		for d := range disconnections {
+			if d.Error != nil {
+				log.Error("peer drop", "err", d.Error)
+				continue
+			}
+			log.Warn("peer drop", "node", d.NodeID, "peer", d.Event.Peer)
+		}
+	}()
+}
+
+// Watch multiple types of events or messages. In this case, they differ only
+// by MsgCode, but filters can be set for different types or protocols, too.
+func ExampleSimulation_PeerEvents_multipleFilters() {
+	sim := simulation.New(nil)
+	defer sim.Close()
+
+	msgs := sim.PeerEvents(
+		context.Background(),
+		sim.NodeIDs(),
+		// Watch when bzz messages 1 and 4 are received.
+		simulation.NewPeerEventsFilter().Type(p2p.PeerEventTypeMsgRecv).Protocol("bzz").MsgCode(1),
+		simulation.NewPeerEventsFilter().Type(p2p.PeerEventTypeMsgRecv).Protocol("bzz").MsgCode(4),
+	)
+
+	go func() {
+		for m := range msgs {
+			if m.Error != nil {
+				log.Error("bzz message", "err", m.Error)
+				continue
+			}
+			log.Info("bzz message", "node", m.NodeID, "peer", m.Event.Peer)
+		}
+	}()
+}

swarm/network/simulation/http.go

+// 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 (
+	"fmt"
+	"net/http"
+
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/p2p/simulations"
+)
+
+// Package defaults.
+var (
+	DefaultHTTPSimAddr = ":8888"
+)
+
+//`With`(builder) pattern constructor for Simulation to
+//start with a HTTP server
+func (s *Simulation) WithServer(addr string) *Simulation {
+	//assign default addr if nothing provided
+	if addr == "" {
+		addr = DefaultHTTPSimAddr
+	}
+	log.Info(fmt.Sprintf("Initializing simulation server on %s...", addr))
+	//initialize the HTTP server
+	s.handler = simulations.NewServer(s.Net)
+	s.runC = make(chan struct{})
+	//add swarm specific routes to the HTTP server
+	s.addSimulationRoutes()
+	s.httpSrv = &http.Server{
+		Addr:    addr,
+		Handler: s.handler,
+	}
+	go s.httpSrv.ListenAndServe()
+	return s
+}
+
+//register additional HTTP routes
+func (s *Simulation) addSimulationRoutes() {
+	s.handler.POST("/runsim", s.RunSimulation)
+}
+
+// StartNetwork starts all nodes in the network
+func (s *Simulation) RunSimulation(w http.ResponseWriter, req *http.Request) {
+	log.Debug("RunSimulation endpoint running")
+	s.runC <- struct{}{}
+	w.WriteHeader(http.StatusOK)
+}

swarm/network/simulation/http_test.go

+// 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 (
+	"context"
+	"fmt"
+	"net/http"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/node"
+	"github.com/ethereum/go-ethereum/p2p/simulations/adapters"
+)
+
+func TestSimulationWithHTTPServer(t *testing.T) {
+	log.Debug("Init simulation")
+
+	ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
+	defer cancel()
+
+	sim := New(
+		map[string]ServiceFunc{
+			"noop": func(_ *adapters.ServiceContext, b *sync.Map) (node.Service, func(), error) {
+				return newNoopService(), nil, nil
+			},
+		}).WithServer(DefaultHTTPSimAddr)
+	defer sim.Close()
+	log.Debug("Done.")
+
+	_, err := sim.AddNode()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	log.Debug("Starting sim round and let it time out...")
+	//first test that running without sending to the channel will actually
+	//block the simulation, so let it time out
+	result := sim.Run(ctx, func(ctx context.Context, sim *Simulation) error {
+		log.Debug("Just start the sim without any action and wait for the timeout")
+		//ensure with a Sleep that simulation doesn't terminate before the timeout
+		time.Sleep(2 * time.Second)
+		return nil
+	})
+
+	if result.Error != nil {
+		if result.Error.Error() == "context deadline exceeded" {
+			log.Debug("Expected timeout error received")
+		} else {
+			t.Fatal(result.Error)
+		}
+	}
+
+	//now run it again and send the expected signal on the waiting channel,
+	//then close the simulation
+	log.Debug("Starting sim round and wait for frontend signal...")
+	//this time the timeout should be long enough so that it doesn't kick in too early
+	ctx, cancel2 := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel2()
+	go sendRunSignal(t)
+	result = sim.Run(ctx, func(ctx context.Context, sim *Simulation) error {
+		log.Debug("This run waits for the run signal from `frontend`...")
+		//ensure with a Sleep that simulation doesn't terminate before the signal is received
+		time.Sleep(2 * time.Second)
+		return nil
+	})
+	if result.Error != nil {
+		t.Fatal(result.Error)
+	}
+	log.Debug("Test terminated successfully")
+}
+
+func sendRunSignal(t *testing.T) {
+	//We need to first wait for the sim HTTP server to start running...
+	time.Sleep(2 * time.Second)
+	//then we can send the signal
+
+	log.Debug("Sending run signal to simulation: POST /runsim...")
+	resp, err := http.Post(fmt.Sprintf("http://localhost%s/runsim", DefaultHTTPSimAddr), "application/json", nil)
+	if err != nil {
+		t.Fatalf("Request failed: %v", err)
+	}
+	defer resp.Body.Close()
+	log.Debug("Signal sent")
+	if resp.StatusCode != http.StatusOK {
+		t.Fatalf("err %s", resp.Status)
+	}
+}

swarm/network/simulation/kademlia.go

+// 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 (
+	"context"
+	"encoding/hex"
+	"time"
+
+	"github.com/ethereum/go-ethereum/p2p/discover"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/swarm/network"
+)
+
+// BucketKeyKademlia is the key to be used for storing the kademlia
+// instance for particuar node, usually inside the ServiceFunc function.
+var BucketKeyKademlia BucketKey = "kademlia"
+
+// WaitTillHealthy is blocking until the health of all kademlias is true.
+// If error is not nil, a map of kademlia that was found not healthy is returned.
+func (s *Simulation) WaitTillHealthy(ctx context.Context, kadMinProxSize int) (ill map[discover.NodeID]*network.Kademlia, err error) {
+	// Prepare PeerPot map for checking Kademlia health
+	var ppmap map[string]*network.PeerPot
+	kademlias := s.kademlias()
+	addrs := make([][]byte, 0, len(kademlias))
+	for _, k := range kademlias {
+		addrs = append(addrs, k.BaseAddr())
+	}
+	ppmap = network.NewPeerPotMap(kadMinProxSize, addrs)
+
+	// Wait for healthy Kademlia on every node before checking files
+	ticker := time.NewTicker(200 * time.Millisecond)
+	defer ticker.Stop()
+
+	ill = make(map[discover.NodeID]*network.Kademlia)
+	for {
+		select {
+		case <-ctx.Done():
+			return ill, ctx.Err()
+		case <-ticker.C:
+			for k := range ill {
+				delete(ill, k)
+			}
+			log.Debug("kademlia health check", "addr count", len(addrs))
+			for id, k := range kademlias {
+				//PeerPot for this node
+				addr := common.Bytes2Hex(k.BaseAddr())
+				pp := ppmap[addr]
+				//call Healthy RPC
+				h := k.Healthy(pp)
+				//print info
+				log.Debug(k.String())
+				log.Debug("kademlia", "empty bins", pp.EmptyBins, "gotNN", h.GotNN, "knowNN", h.KnowNN, "full", h.Full)
+				log.Debug("kademlia", "health", h.GotNN && h.KnowNN && h.Full, "addr", hex.EncodeToString(k.BaseAddr()), "node", id)
+				log.Debug("kademlia", "ill condition", !h.GotNN || !h.Full, "addr", hex.EncodeToString(k.BaseAddr()), "node", id)
+				if !h.GotNN || !h.Full {
+					ill[id] = k
+				}
+			}
+			if len(ill) == 0 {
+				return nil, nil
+			}
+		}
+	}
+}
+
+// kademlias returns all Kademlia instances that are set
+// in simulation bucket.
+func (s *Simulation) kademlias() (ks map[discover.NodeID]*network.Kademlia) {
+	items := s.UpNodesItems(BucketKeyKademlia)
+	ks = make(map[discover.NodeID]*network.Kademlia, len(items))
+	for id, v := range items {
+		k, ok := v.(*network.Kademlia)
+		if !ok {
+			continue
+		}
+		ks[id] = k
+	}
+	return ks
+}

swarm/network/simulation/kademlia_test.go

+// 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 (
+	"context"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/ethereum/go-ethereum/node"
+	"github.com/ethereum/go-ethereum/p2p/simulations/adapters"
+	"github.com/ethereum/go-ethereum/swarm/network"
+)
+
+func TestWaitTillHealthy(t *testing.T) {
+	sim := New(map[string]ServiceFunc{
+		"bzz": func(ctx *adapters.ServiceContext, b *sync.Map) (node.Service, func(), error) {
+			addr := network.NewAddrFromNodeID(ctx.Config.ID)
+			hp := network.NewHiveParams()
+			hp.Discovery = false
+			config := &network.BzzConfig{
+				OverlayAddr:  addr.Over(),
+				UnderlayAddr: addr.Under(),
+				HiveParams:   hp,
+			}
+			kad := network.NewKademlia(addr.Over(), network.NewKadParams())
+			// store kademlia in node's bucket under BucketKeyKademlia
+			// so that it can be found by WaitTillHealthy method.
+			b.Store(BucketKeyKademlia, kad)
+			return network.NewBzz(config, kad, nil, nil, nil), nil, nil
+		},
+	})
+	defer sim.Close()
+
+	_, err := sim.AddNodesAndConnectRing(10)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 120*time.Second)
+	defer cancel()
+	ill, err := sim.WaitTillHealthy(ctx, 2)
+	if err != nil {
+		for id, kad := range ill {
+			t.Log("Node", id)
+			t.Log(kad.String())
+		}
+		if err != nil {
+			t.Fatal(err)
+		}
+	}
+}

swarm/network/simulation/service.go

+// 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 (
+	"github.com/ethereum/go-ethereum/node"
+	"github.com/ethereum/go-ethereum/p2p/discover"
+	"github.com/ethereum/go-ethereum/p2p/simulations/adapters"
+)
+
+// Service returns a single Service by name on a particular node
+// with provided id.
+func (s *Simulation) Service(name string, id discover.NodeID) node.Service {
+	simNode, ok := s.Net.GetNode(id).Node.(*adapters.SimNode)
+	if !ok {
+		return nil
+	}
+	services := simNode.ServiceMap()
+	if len(services) == 0 {
+		return nil
+	}
+	return services[name]
+}
+
+// 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()
+	if n == nil {
+		return nil
+	}
+	return n.Service(name)
+}
+
+// Services returns all services with a provided name
+// from nodes that are up.
+func (s *Simulation) Services(name string) (services map[discover.NodeID]node.Service) {
+	nodes := s.Net.GetNodes()
+	services = make(map[discover.NodeID]node.Service)
+	for _, node := range nodes {
+		if !node.Up {
+			continue
+		}
+		simNode, ok := node.Node.(*adapters.SimNode)
+		if !ok {
+			continue
+		}
+		services[node.ID()] = simNode.Service(name)
+	}
+	return services
+}

swarm/network/simulation/service_test.go

+// 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"
+)
+
+func TestService(t *testing.T) {
+	sim := New(noopServiceFuncMap)
+	defer sim.Close()
+
+	id, err := sim.AddNode()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	_, ok := sim.Service("noop", id).(*noopService)
+	if !ok {
+		t.Fatalf("service is not of %T type", &noopService{})
+	}
+
+	_, ok = sim.RandomService("noop").(*noopService)
+	if !ok {
+		t.Fatalf("service is not of %T type", &noopService{})
+	}
+
+	_, ok = sim.Services("noop")[id].(*noopService)
+	if !ok {
+		t.Fatalf("service is not of %T type", &noopService{})
+	}
+}

swarm/network/simulation/simulation.go

+// 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 (
+	"context"
+	"errors"
+	"net/http"
+	"sync"
+	"time"
+
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/node"
+	"github.com/ethereum/go-ethereum/p2p/discover"
+	"github.com/ethereum/go-ethereum/p2p/simulations"
+	"github.com/ethereum/go-ethereum/p2p/simulations/adapters"
+)
+
+// 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
+// to manage them.
+type Simulation struct {
+	// Net is exposed as a way to access lower level functionalities
+	// of p2p/simulations.Network.
+	Net *simulations.Network
+
+	serviceNames []string
+	cleanupFuncs []func()
+	buckets      map[discover.NodeID]*sync.Map
+	pivotNodeID  *discover.NodeID
+	shutdownWG   sync.WaitGroup
+	done         chan struct{}
+	mu           sync.RWMutex
+
+	httpSrv *http.Server        //attach a HTTP server via SimulationOptions
+	handler *simulations.Server //HTTP handler for the server
+	runC    chan struct{}       //channel where frontend signals it is ready
+}
+
+// ServiceFunc is used in New to declare new service constructor.
+// The first argument provides ServiceContext from the adapters package
+// giving for example the access to NodeID. Second argument is the sync.Map
+// where all "global" state related to the service should be kept.
+// All cleanups needed for constructed service and any other constructed
+// objects should ne provided in a single returned cleanup function.
+type ServiceFunc func(ctx *adapters.ServiceContext, bucket *sync.Map) (s node.Service, cleanup func(), err error)
+
+// New creates a new Simulation instance with new
+// simulations.Network initialized with provided services.
+func New(services map[string]ServiceFunc) (s *Simulation) {
+	s = &Simulation{
+		buckets: make(map[discover.NodeID]*sync.Map),
+		done:    make(chan struct{}),
+	}
+
+	adapterServices := make(map[string]adapters.ServiceFunc, len(services))
+	for name, serviceFunc := range services {
+		s.serviceNames = append(s.serviceNames, name)
+		adapterServices[name] = func(ctx *adapters.ServiceContext) (node.Service, error) {
+			b := new(sync.Map)
+			service, cleanup, err := serviceFunc(ctx, b)
+			if err != nil {
+				return nil, err
+			}
+			s.mu.Lock()
+			defer s.mu.Unlock()
+			if cleanup != nil {
+				s.cleanupFuncs = append(s.cleanupFuncs, cleanup)
+			}
+			s.buckets[ctx.Config.ID] = b
+			return service, nil
+		}
+	}
+
+	s.Net = simulations.NewNetwork(
+		adapters.NewSimAdapter(adapterServices),
+		&simulations.NetworkConfig{ID: "0"},
+	)
+
+	return s
+}
+
+// RunFunc is the function that will be called
+// on Simulation.Run method call.
+type RunFunc func(context.Context, *Simulation) error
+
+// Result is the returned value of Simulation.Run method.
+type Result struct {
+	Duration time.Duration
+	Error    error
+}
+
+// Run calls the RunFunc function while taking care of
+// cancelation provided through the Context.
+func (s *Simulation) Run(ctx context.Context, f RunFunc) (r Result) {
+	//if the option is set to run a HTTP server with the simulation,
+	//init the server and start it
+	start := time.Now()
+	if s.httpSrv != nil {
+		log.Info("Waiting for frontend to be ready...(send POST /runsim to HTTP server)")
+		//wait for the frontend to connect
+		select {
+		case <-s.runC:
+		case <-ctx.Done():
+			return Result{
+				Duration: time.Since(start),
+				Error:    ctx.Err(),
+			}
+		}
+		log.Info("Received signal from frontend - starting simulation run.")
+	}
+	errc := make(chan error)
+	quit := make(chan struct{})
+	defer close(quit)
+	go func() {
+		select {
+		case errc <- f(ctx, s):
+		case <-quit:
+		}
+	}()
+	var err error
+	select {
+	case <-ctx.Done():
+		err = ctx.Err()
+	case err = <-errc:
+	}
+	return Result{
+		Duration: time.Since(start),
+		Error:    err,
+	}
+}
+
+// Maximal number of parallel calls to cleanup functions on
+// Simulation.Close.
+var maxParallelCleanups = 10
+
+// Close calls all cleanup functions that are returned by
+// ServiceFunc, waits for all of them to finish and other
+// functions that explicitly block shutdownWG
+// (like Simulation.PeerEvents) and shuts down the network
+// at the end. It is used to clean all resources from the
+// simulation.
+func (s *Simulation) Close() {
+	close(s.done)
+	sem := make(chan struct{}, maxParallelCleanups)
+	s.mu.RLock()
+	cleanupFuncs := make([]func(), len(s.cleanupFuncs))
+	for i, f := range s.cleanupFuncs {
+		if f != nil {
+			cleanupFuncs[i] = f
+		}
+	}
+	s.mu.RUnlock()
+	for _, cleanup := range cleanupFuncs {
+		s.shutdownWG.Add(1)
+		sem <- struct{}{}
+		go func(cleanup func()) {
+			defer s.shutdownWG.Done()
+			defer func() { <-sem }()
+
+			cleanup()
+		}(cleanup)
+	}
+	if s.httpSrv != nil {
+		ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
+		defer cancel()
+		err := s.httpSrv.Shutdown(ctx)
+		if err != nil {
+			log.Error("Error shutting down HTTP server!", "err", err)
+		}
+		close(s.runC)
+	}
+	s.shutdownWG.Wait()
+	s.Net.Shutdown()
+}
+
+// Done returns a channel that is closed when the simulation
+// is closed by Close method. It is useful for signaling termination
+// of all possible goroutines that are created within the test.
+func (s *Simulation) Done() <-chan struct{} {
+	return s.done
+}

swarm/network/simulation/simulation_test.go

+// 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 (
+	"context"
+	"errors"
+	"flag"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/node"
+	"github.com/ethereum/go-ethereum/p2p"
+	"github.com/ethereum/go-ethereum/p2p/simulations/adapters"
+	"github.com/ethereum/go-ethereum/rpc"
+	colorable "github.com/mattn/go-colorable"
+)
+
+var (
+	loglevel = flag.Int("loglevel", 2, "verbosity of logs")
+)
+
+func init() {
+	flag.Parse()
+	log.PrintOrigins(true)
+	log.Root().SetHandler(log.LvlFilterHandler(log.Lvl(*loglevel), log.StreamHandler(colorable.NewColorableStderr(), log.TerminalFormat(true))))
+}
+
+// TestRun tests if Run method calls RunFunc and if it handles context properly.
+func TestRun(t *testing.T) {
+	sim := New(noopServiceFuncMap)
+	defer sim.Close()
+
+	t.Run("call", func(t *testing.T) {
+		expect := "something"
+		var got string
+		r := sim.Run(context.Background(), func(ctx context.Context, sim *Simulation) error {
+			got = expect
+			return nil
+		})
+
+		if r.Error != nil {
+			t.Errorf("unexpected error: %v", r.Error)
+		}
+		if got != expect {
+			t.Errorf("expected %q, got %q", expect, got)
+		}
+	})
+
+	t.Run("cancelation", func(t *testing.T) {
+		ctx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond)
+		defer cancel()
+
+		r := sim.Run(ctx, func(ctx context.Context, sim *Simulation) error {
+			time.Sleep(100 * time.Millisecond)
+			return nil
+		})
+
+		if r.Error != context.DeadlineExceeded {
+			t.Errorf("unexpected error: %v", r.Error)
+		}
+	})
+
+	t.Run("context value and duration", func(t *testing.T) {
+		ctx := context.WithValue(context.Background(), "hey", "there")
+		sleep := 50 * time.Millisecond
+
+		r := sim.Run(ctx, func(ctx context.Context, sim *Simulation) error {
+			if ctx.Value("hey") != "there" {
+				return errors.New("expected context value not passed")
+			}
+			time.Sleep(sleep)
+			return nil
+		})
+
+		if r.Error != nil {
+			t.Errorf("unexpected error: %v", r.Error)
+		}
+		if r.Duration < sleep {
+			t.Errorf("reported run duration less then expected: %s", r.Duration)
+		}
+	})
+}
+
+// TestClose tests are Close method triggers all close functions and are all nodes not up anymore.
+func TestClose(t *testing.T) {
+	var mu sync.Mutex
+	var cleanupCount int
+
+	sleep := 50 * time.Millisecond
+
+	sim := New(map[string]ServiceFunc{
+		"noop": func(ctx *adapters.ServiceContext, b *sync.Map) (node.Service, func(), error) {
+			return newNoopService(), func() {
+				time.Sleep(sleep)
+				mu.Lock()
+				defer mu.Unlock()
+				cleanupCount++
+			}, nil
+		},
+	})
+
+	nodeCount := 30
+
+	_, err := sim.AddNodes(nodeCount)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var upNodeCount int
+	for _, n := range sim.Net.GetNodes() {
+		if n.Up {
+			upNodeCount++
+		}
+	}
+	if upNodeCount != nodeCount {
+		t.Errorf("all nodes should be up, insted only %v are up", upNodeCount)
+	}
+
+	sim.Close()
+
+	if cleanupCount != nodeCount {
+		t.Errorf("number of cleanups expected %v, got %v", nodeCount, cleanupCount)
+	}
+
+	upNodeCount = 0
+	for _, n := range sim.Net.GetNodes() {
+		if n.Up {
+			upNodeCount++
+		}
+	}
+	if upNodeCount != 0 {
+		t.Errorf("all nodes should be down, insted %v are up", upNodeCount)
+	}
+}
+
+// TestDone checks if Close method triggers the closing of done channel.
+func TestDone(t *testing.T) {
+	sim := New(noopServiceFuncMap)
+	sleep := 50 * time.Millisecond
+	timeout := 2 * time.Second
+
+	start := time.Now()
+	go func() {
+		time.Sleep(sleep)
+		sim.Close()
+	}()
+
+	select {
+	case <-time.After(timeout):
+		t.Error("done channel closing timmed out")
+	case <-sim.Done():
+		if d := time.Since(start); d < sleep {
+			t.Errorf("done channel closed sooner then expected: %s", d)
+		}
+	}
+}
+
+// a helper map for usual services that do not do anyting
+var noopServiceFuncMap = map[string]ServiceFunc{
+	"noop": noopServiceFunc,
+}
+
+// a helper function for most basic noop service
+func noopServiceFunc(ctx *adapters.ServiceContext, b *sync.Map) (node.Service, func(), error) {
+	return newNoopService(), nil, nil
+}
+
+// noopService is the service that does not do anything
+// but implements node.Service interface.
+type noopService struct{}
+
+func newNoopService() node.Service {
+	return &noopService{}
+}
+
+func (t *noopService) Protocols() []p2p.Protocol {
+	return []p2p.Protocol{}
+}
+
+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
+}