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

1 files changed, 157 insertions, 0 deletions

diff --git a/swarm/network/simulation/events.go b/swarm/network/simulation/events.go
new file mode 100644
index 000000000..f9cfadb73
--- /dev/null
+++ b/swarm/network/simulation/events.go
@@ -0,0 +1,157 @@
+// 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
+}